RTEMS 4.11Annotated Report
Sun Sep 11 19:41:55 2011
ffc0e17c <IMFS_Set_handlers>:
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
switch( node->type ) {
ffc0e17c: 81 63 00 00 lwz r11,0(r3)
)
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
ffc0e180: 81 23 00 10 lwz r9,16(r3)
switch( node->type ) {
ffc0e184: 80 0b 00 4c lwz r0,76(r11)
)
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
ffc0e188: 81 29 00 34 lwz r9,52(r9)
switch( node->type ) {
ffc0e18c: 2b 80 00 07 cmplwi cr7,r0,7
ffc0e190: 41 9d 00 28 bgt- cr7,ffc0e1b8 <IMFS_Set_handlers+0x3c> <== NEVER TAKEN
ffc0e194: 3d 60 ff c2 lis r11,-62
ffc0e198: 39 6b 0d 48 addi r11,r11,3400
ffc0e19c: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc0e1a0: 7c 0b 00 2e lwzx r0,r11,r0
ffc0e1a4: 7d 60 5a 14 add r11,r0,r11
ffc0e1a8: 7d 69 03 a6 mtctr r11
ffc0e1ac: 4e 80 04 20 bctr
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
ffc0e1b0: 80 09 00 0c lwz r0,12(r9)
ffc0e1b4: 90 03 00 08 stw r0,8(r3)
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
ffc0e1b8: 38 60 00 00 li r3,0
ffc0e1bc: 4e 80 00 20 blr
break;
case IMFS_LINEAR_FILE:
loc->handlers = fs_info->memfile_handlers;
break;
case IMFS_MEMORY_FILE:
loc->handlers = fs_info->memfile_handlers;
ffc0e1c0: 80 09 00 08 lwz r0,8(r9)
ffc0e1c4: 90 03 00 08 stw r0,8(r3)
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
ffc0e1c8: 38 60 00 00 li r3,0
ffc0e1cc: 4e 80 00 20 blr
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
break;
case IMFS_SYM_LINK:
case IMFS_HARD_LINK:
loc->handlers = &IMFS_link_handlers;
ffc0e1d0: 3d 20 ff c2 lis r9,-62
ffc0e1d4: 38 09 0d e8 addi r0,r9,3560
ffc0e1d8: 90 03 00 08 stw r0,8(r3)
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
ffc0e1dc: 38 60 00 00 li r3,0
ffc0e1e0: 4e 80 00 20 blr
break;
case IMFS_MEMORY_FILE:
loc->handlers = fs_info->memfile_handlers;
break;
case IMFS_FIFO:
loc->handlers = fs_info->fifo_handlers;
ffc0e1e4: 80 09 00 10 lwz r0,16(r9)
ffc0e1e8: 90 03 00 08 stw r0,8(r3)
break;
}
return 0;
}
ffc0e1ec: 38 60 00 00 li r3,0
ffc0e1f0: 4e 80 00 20 blr
switch( node->type ) {
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
break;
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
ffc0e1f4: 3d 20 ff c2 lis r9,-62
ffc0e1f8: 38 09 0d 78 addi r0,r9,3448
ffc0e1fc: 90 03 00 08 stw r0,8(r3)
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
ffc0e200: 38 60 00 00 li r3,0
ffc0e204: 4e 80 00 20 blr
ffc0ddd8 <IMFS_chown>:
int IMFS_chown(
rtems_filesystem_location_info_t *pathloc, /* IN */
uid_t owner, /* IN */
gid_t group /* IN */
)
{
ffc0ddd8: 94 21 ff d8 stwu r1,-40(r1)
ffc0dddc: 7c 08 02 a6 mflr r0
ffc0dde0: 90 01 00 2c stw r0,44(r1)
ffc0dde4: 93 e1 00 24 stw r31,36(r1)
IMFS_jnode_t *jnode;
#if defined(RTEMS_POSIX_API)
uid_t st_uid;
#endif
jnode = (IMFS_jnode_t *) pathloc->node_access;
ffc0dde8: 83 e3 00 00 lwz r31,0(r3)
int IMFS_chown(
rtems_filesystem_location_info_t *pathloc, /* IN */
uid_t owner, /* IN */
gid_t group /* IN */
)
{
ffc0ddec: 93 a1 00 1c stw r29,28(r1)
ffc0ddf0: 7c bd 2b 78 mr r29,r5
ffc0ddf4: 93 c1 00 20 stw r30,32(r1)
ffc0ddf8: 7c 9e 23 78 mr r30,r4
/*
* Verify I am the owner of the node or the super user.
*/
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
ffc0ddfc: 48 00 17 65 bl ffc0f560 <geteuid>
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
ffc0de00: a0 1f 00 3c lhz r0,60(r31)
ffc0de04: 7f 80 18 00 cmpw cr7,r0,r3
ffc0de08: 41 9e 00 0c beq- cr7,ffc0de14 <IMFS_chown+0x3c>
ffc0de0c: 2f 83 00 00 cmpwi cr7,r3,0
ffc0de10: 40 9e 00 40 bne- cr7,ffc0de50 <IMFS_chown+0x78> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
#endif
jnode->st_uid = owner;
ffc0de14: b3 df 00 3c sth r30,60(r31)
jnode->st_gid = group;
IMFS_update_ctime( jnode );
ffc0de18: 38 61 00 08 addi r3,r1,8
ffc0de1c: 38 80 00 00 li r4,0
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
rtems_set_errno_and_return_minus_one( EPERM );
#endif
jnode->st_uid = owner;
jnode->st_gid = group;
ffc0de20: b3 bf 00 3e sth r29,62(r31)
IMFS_update_ctime( jnode );
ffc0de24: 4b ff 74 41 bl ffc05264 <gettimeofday>
ffc0de28: 80 01 00 08 lwz r0,8(r1)
return 0;
ffc0de2c: 38 60 00 00 li r3,0
#endif
jnode->st_uid = owner;
jnode->st_gid = group;
IMFS_update_ctime( jnode );
ffc0de30: 90 1f 00 48 stw r0,72(r31)
return 0;
}
ffc0de34: 80 01 00 2c lwz r0,44(r1)
ffc0de38: 83 a1 00 1c lwz r29,28(r1)
ffc0de3c: 7c 08 03 a6 mtlr r0
ffc0de40: 83 c1 00 20 lwz r30,32(r1)
ffc0de44: 83 e1 00 24 lwz r31,36(r1)
ffc0de48: 38 21 00 28 addi r1,r1,40
ffc0de4c: 4e 80 00 20 blr
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
rtems_set_errno_and_return_minus_one( EPERM );
ffc0de50: 48 00 5f 3d bl ffc13d8c <__errno>
ffc0de54: 38 00 00 01 li r0,1
ffc0de58: 90 03 00 00 stw r0,0(r3)
ffc0de5c: 38 60 ff ff li r3,-1
ffc0de60: 4b ff ff d4 b ffc0de34 <IMFS_chown+0x5c>
ffc0df10 <IMFS_create_node>:
IMFS_jnode_types_t type,
const char *name,
mode_t mode,
const IMFS_types_union *info
)
{
ffc0df10: 7d 80 00 26 mfcr r12
IMFS_fs_info_t *fs_info;
/*
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
ffc0df14: 7c 69 1b 79 mr. r9,r3
IMFS_jnode_types_t type,
const char *name,
mode_t mode,
const IMFS_types_union *info
)
{
ffc0df18: 94 21 ff e0 stwu r1,-32(r1)
ffc0df1c: 7c 08 02 a6 mflr r0
ffc0df20: 93 61 00 0c stw r27,12(r1)
/*
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
return NULL;
ffc0df24: 3b 60 00 00 li r27,0
IMFS_jnode_types_t type,
const char *name,
mode_t mode,
const IMFS_types_union *info
)
{
ffc0df28: 93 81 00 10 stw r28,16(r1)
ffc0df2c: 7c fc 3b 78 mr r28,r7
ffc0df30: 93 e1 00 1c stw r31,28(r1)
ffc0df34: 7c 9f 23 78 mr r31,r4
ffc0df38: 90 01 00 24 stw r0,36(r1)
ffc0df3c: 93 a1 00 14 stw r29,20(r1)
ffc0df40: 93 c1 00 18 stw r30,24(r1)
ffc0df44: 91 81 00 08 stw r12,8(r1)
IMFS_fs_info_t *fs_info;
/*
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
ffc0df48: 41 82 00 a4 beq- ffc0dfec <IMFS_create_node+0xdc> <== NEVER TAKEN
fs_info = parent_loc->mt_entry->fs_info;
/*
* Reject creation of FIFOs if support is disabled.
*/
if ( type == IMFS_FIFO &&
ffc0df4c: 2e 04 00 07 cmpwi cr4,r4,7
*/
if ( parent_loc == NULL )
return NULL;
parent = parent_loc->node_access;
fs_info = parent_loc->mt_entry->fs_info;
ffc0df50: 81 69 00 10 lwz r11,16(r9)
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
return NULL;
parent = parent_loc->node_access;
ffc0df54: 83 a9 00 00 lwz r29,0(r9)
fs_info = parent_loc->mt_entry->fs_info;
ffc0df58: 83 cb 00 34 lwz r30,52(r11)
/*
* Reject creation of FIFOs if support is disabled.
*/
if ( type == IMFS_FIFO &&
ffc0df5c: 41 92 00 c0 beq- cr4,ffc0e01c <IMFS_create_node+0x10c>
return NULL;
/*
* Allocate filesystem node and fill in basic information
*/
node = IMFS_allocate_node( type, name, mode & ~rtems_filesystem_umask );
ffc0df60: 3d 20 00 00 lis r9,0
ffc0df64: 81 29 27 7c lwz r9,10108(r9)
ffc0df68: 7c a4 2b 78 mr r4,r5
ffc0df6c: 7f e3 fb 78 mr r3,r31
ffc0df70: 80 09 00 2c lwz r0,44(r9)
ffc0df74: 7c c5 00 78 andc r5,r6,r0
ffc0df78: 4b ff fe ed bl ffc0de64 <IMFS_allocate_node>
if ( !node )
ffc0df7c: 7c 7b 1b 79 mr. r27,r3
ffc0df80: 41 82 00 6c beq- ffc0dfec <IMFS_create_node+0xdc>
return NULL;
/*
* Set the type specific information
*/
if ( type == IMFS_DIRECTORY ) {
ffc0df84: 2f 9f 00 01 cmpwi cr7,r31,1
ffc0df88: 41 9e 00 ac beq- cr7,ffc0e034 <IMFS_create_node+0x124>
rtems_chain_initialize_empty(&node->info.directory.Entries);
} else if ( type == IMFS_HARD_LINK ) {
ffc0df8c: 2f 9f 00 03 cmpwi cr7,r31,3
ffc0df90: 41 9e 00 34 beq- cr7,ffc0dfc4 <IMFS_create_node+0xb4>
node->info.hard_link.link_node = info->hard_link.link_node;
} else if ( type == IMFS_SYM_LINK ) {
ffc0df94: 2f 9f 00 04 cmpwi cr7,r31,4
ffc0df98: 41 9e 00 2c beq- cr7,ffc0dfc4 <IMFS_create_node+0xb4>
node->info.sym_link.name = info->sym_link.name;
} else if ( type == IMFS_DEVICE ) {
ffc0df9c: 2f 9f 00 02 cmpwi cr7,r31,2
ffc0dfa0: 41 9e 00 cc beq- cr7,ffc0e06c <IMFS_create_node+0x15c>
node->info.device.major = info->device.major;
node->info.device.minor = info->device.minor;
} else if ( type == IMFS_LINEAR_FILE ) {
ffc0dfa4: 2f 9f 00 06 cmpwi cr7,r31,6
ffc0dfa8: 41 9e 00 a8 beq- cr7,ffc0e050 <IMFS_create_node+0x140>
node->info.linearfile.size = 0;
node->info.linearfile.direct = 0;
} else if ( type == IMFS_MEMORY_FILE ) {
ffc0dfac: 2f 9f 00 05 cmpwi cr7,r31,5
ffc0dfb0: 41 9e 00 d0 beq- cr7,ffc0e080 <IMFS_create_node+0x170>
node->info.file.size = 0;
node->info.file.indirect = 0;
node->info.file.doubly_indirect = 0;
node->info.file.triply_indirect = 0;
} else if ( type == IMFS_FIFO ) {
ffc0dfb4: 40 b2 00 18 bne+ cr4,ffc0dfcc <IMFS_create_node+0xbc> <== NEVER TAKEN
node->info.fifo.pipe = NULL;
ffc0dfb8: 38 00 00 00 li r0,0
ffc0dfbc: 90 1b 00 50 stw r0,80(r27)
ffc0dfc0: 48 00 00 0c b ffc0dfcc <IMFS_create_node+0xbc>
if ( type == IMFS_DIRECTORY ) {
rtems_chain_initialize_empty(&node->info.directory.Entries);
} else if ( type == IMFS_HARD_LINK ) {
node->info.hard_link.link_node = info->hard_link.link_node;
} else if ( type == IMFS_SYM_LINK ) {
node->info.sym_link.name = info->sym_link.name;
ffc0dfc4: 80 1c 00 00 lwz r0,0(r28)
ffc0dfc8: 90 1b 00 50 stw r0,80(r27)
/*
* This node MUST have a parent, so put it in that directory list.
*/
node->Parent = parent;
node->st_ino = ++fs_info->ino_count;
ffc0dfcc: 81 3e 00 04 lwz r9,4(r30)
ffc0dfd0: 38 7d 00 50 addi r3,r29,80
}
/*
* This node MUST have a parent, so put it in that directory list.
*/
node->Parent = parent;
ffc0dfd4: 93 bb 00 08 stw r29,8(r27)
ffc0dfd8: 7f 64 db 78 mr r4,r27
node->st_ino = ++fs_info->ino_count;
ffc0dfdc: 38 09 00 01 addi r0,r9,1
ffc0dfe0: 90 1e 00 04 stw r0,4(r30)
ffc0dfe4: 90 1b 00 38 stw r0,56(r27)
ffc0dfe8: 4b ff c2 05 bl ffc0a1ec <_Chain_Append>
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
return node;
}
ffc0dfec: 80 01 00 24 lwz r0,36(r1)
ffc0dff0: 7f 63 db 78 mr r3,r27
ffc0dff4: 81 81 00 08 lwz r12,8(r1)
ffc0dff8: 7c 08 03 a6 mtlr r0
ffc0dffc: 83 61 00 0c lwz r27,12(r1)
ffc0e000: 83 81 00 10 lwz r28,16(r1)
ffc0e004: 7d 80 81 20 mtcrf 8,r12
ffc0e008: 83 a1 00 14 lwz r29,20(r1)
ffc0e00c: 83 c1 00 18 lwz r30,24(r1)
ffc0e010: 83 e1 00 1c lwz r31,28(r1)
ffc0e014: 38 21 00 20 addi r1,r1,32
ffc0e018: 4e 80 00 20 blr
fs_info = parent_loc->mt_entry->fs_info;
/*
* Reject creation of FIFOs if support is disabled.
*/
if ( type == IMFS_FIFO &&
ffc0e01c: 81 3e 00 10 lwz r9,16(r30)
ffc0e020: 3d 60 ff c2 lis r11,-62
ffc0e024: 38 0b 0c e0 addi r0,r11,3296
ffc0e028: 7f 89 00 00 cmpw cr7,r9,r0
ffc0e02c: 40 9e ff 34 bne+ cr7,ffc0df60 <IMFS_create_node+0x50>
ffc0e030: 4b ff ff bc b ffc0dfec <IMFS_create_node+0xdc>
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 );
ffc0e034: 39 3b 00 54 addi r9,r27,84
ffc0e038: 38 1b 00 50 addi r0,r27,80
head->next = tail;
ffc0e03c: 91 3b 00 50 stw r9,80(r27)
head->previous = NULL;
ffc0e040: 39 20 00 00 li r9,0
ffc0e044: 91 3b 00 54 stw r9,84(r27)
tail->previous = head;
ffc0e048: 90 1b 00 58 stw r0,88(r27)
ffc0e04c: 4b ff ff 80 b ffc0dfcc <IMFS_create_node+0xbc>
node->info.sym_link.name = info->sym_link.name;
} else if ( type == IMFS_DEVICE ) {
node->info.device.major = info->device.major;
node->info.device.minor = info->device.minor;
} else if ( type == IMFS_LINEAR_FILE ) {
node->info.linearfile.size = 0;
ffc0e050: 39 40 00 00 li r10,0
ffc0e054: 39 60 00 00 li r11,0
ffc0e058: 91 5b 00 50 stw r10,80(r27)
node->info.linearfile.direct = 0;
ffc0e05c: 38 00 00 00 li r0,0
node->info.sym_link.name = info->sym_link.name;
} else if ( type == IMFS_DEVICE ) {
node->info.device.major = info->device.major;
node->info.device.minor = info->device.minor;
} else if ( type == IMFS_LINEAR_FILE ) {
node->info.linearfile.size = 0;
ffc0e060: 91 7b 00 54 stw r11,84(r27)
node->info.linearfile.direct = 0;
ffc0e064: 90 1b 00 58 stw r0,88(r27)
ffc0e068: 4b ff ff 64 b ffc0dfcc <IMFS_create_node+0xbc>
} else if ( type == IMFS_HARD_LINK ) {
node->info.hard_link.link_node = info->hard_link.link_node;
} else if ( type == IMFS_SYM_LINK ) {
node->info.sym_link.name = info->sym_link.name;
} else if ( type == IMFS_DEVICE ) {
node->info.device.major = info->device.major;
ffc0e06c: 81 3c 00 00 lwz r9,0(r28)
node->info.device.minor = info->device.minor;
ffc0e070: 80 1c 00 04 lwz r0,4(r28)
} else if ( type == IMFS_HARD_LINK ) {
node->info.hard_link.link_node = info->hard_link.link_node;
} else if ( type == IMFS_SYM_LINK ) {
node->info.sym_link.name = info->sym_link.name;
} else if ( type == IMFS_DEVICE ) {
node->info.device.major = info->device.major;
ffc0e074: 91 3b 00 50 stw r9,80(r27)
node->info.device.minor = info->device.minor;
ffc0e078: 90 1b 00 54 stw r0,84(r27)
ffc0e07c: 4b ff ff 50 b ffc0dfcc <IMFS_create_node+0xbc>
} else if ( type == IMFS_LINEAR_FILE ) {
node->info.linearfile.size = 0;
node->info.linearfile.direct = 0;
} else if ( type == IMFS_MEMORY_FILE ) {
node->info.file.size = 0;
node->info.file.indirect = 0;
ffc0e080: 38 00 00 00 li r0,0
node->info.device.minor = info->device.minor;
} else if ( type == IMFS_LINEAR_FILE ) {
node->info.linearfile.size = 0;
node->info.linearfile.direct = 0;
} else if ( type == IMFS_MEMORY_FILE ) {
node->info.file.size = 0;
ffc0e084: 39 40 00 00 li r10,0
node->info.file.indirect = 0;
ffc0e088: 90 1b 00 58 stw r0,88(r27)
node->info.device.minor = info->device.minor;
} else if ( type == IMFS_LINEAR_FILE ) {
node->info.linearfile.size = 0;
node->info.linearfile.direct = 0;
} else if ( type == IMFS_MEMORY_FILE ) {
node->info.file.size = 0;
ffc0e08c: 39 60 00 00 li r11,0
ffc0e090: 91 5b 00 50 stw r10,80(r27)
ffc0e094: 91 7b 00 54 stw r11,84(r27)
node->info.file.indirect = 0;
node->info.file.doubly_indirect = 0;
ffc0e098: 90 1b 00 5c stw r0,92(r27)
node->info.file.triply_indirect = 0;
ffc0e09c: 90 1b 00 60 stw r0,96(r27)
ffc0e0a0: 4b ff ff 2c b ffc0dfcc <IMFS_create_node+0xbc>
ffc07450 <IMFS_dump_directory>:
*/
void IMFS_dump_directory(
IMFS_jnode_t *the_directory,
int level
)
{
ffc07450: 94 21 ff d0 stwu r1,-48(r1)
ffc07454: 7c 08 02 a6 mflr r0
ffc07458: 7d 80 00 26 mfcr r12
ffc0745c: 2e 04 00 00 cmpwi cr4,r4,0
ffc07460: 90 01 00 34 stw r0,52(r1)
ffc07464: 93 61 00 1c stw r27,28(r1)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc07468: 83 63 00 50 lwz r27,80(r3)
ffc0746c: 93 41 00 18 stw r26,24(r1)
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
ffc07470: 3b 43 00 54 addi r26,r3,84
IMFS_assert( level >= 0 );
IMFS_assert( the_directory->type == IMFS_DIRECTORY );
the_chain = &the_directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
ffc07474: 7f 9b d0 00 cmpw cr7,r27,r26
*/
void IMFS_dump_directory(
IMFS_jnode_t *the_directory,
int level
)
{
ffc07478: 93 a1 00 24 stw r29,36(r1)
ffc0747c: 7c 9d 23 78 mr r29,r4
ffc07480: 93 01 00 10 stw r24,16(r1)
ffc07484: 93 21 00 14 stw r25,20(r1)
ffc07488: 93 81 00 20 stw r28,32(r1)
ffc0748c: 93 c1 00 28 stw r30,40(r1)
ffc07490: 93 e1 00 2c stw r31,44(r1)
ffc07494: 91 81 00 0c stw r12,12(r1)
IMFS_assert( level >= 0 );
IMFS_assert( the_directory->type == IMFS_DIRECTORY );
the_chain = &the_directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
ffc07498: 41 9e 00 64 beq- cr7,ffc074fc <IMFS_dump_directory+0xac>
ffc0749c: 3f 80 ff c3 lis r28,-61
ffc074a0: 3b 9c 8e cc addi r28,r28,-28980
ffc074a4: 3f 20 00 00 lis r25,0
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
if ( the_jnode->type == IMFS_DIRECTORY )
IMFS_dump_directory( the_jnode, level + 1 );
ffc074a8: 3b 04 00 01 addi r24,r4,1
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
ffc074ac: 41 90 00 30 blt- cr4,ffc074dc <IMFS_dump_directory+0x8c><== NEVER TAKEN
ffc074b0: 3b e0 00 00 li r31,0
ffc074b4: 3b d9 27 d4 addi r30,r25,10196
fprintf(stdout, "...." );
ffc074b8: 81 3e 00 00 lwz r9,0(r30)
ffc074bc: 7f 83 e3 78 mr r3,r28
ffc074c0: 38 80 00 01 li r4,1
ffc074c4: 80 c9 00 08 lwz r6,8(r9)
ffc074c8: 38 a0 00 04 li r5,4
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
ffc074cc: 3b ff 00 01 addi r31,r31,1
fprintf(stdout, "...." );
ffc074d0: 48 01 2e 4d bl ffc1a31c <fwrite>
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
ffc074d4: 7f 9d f8 00 cmpw cr7,r29,r31
ffc074d8: 40 9c ff e0 bge+ cr7,ffc074b8 <IMFS_dump_directory+0x68>
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
ffc074dc: 7f 63 db 78 mr r3,r27
ffc074e0: 4b ff fd e9 bl ffc072c8 <IMFS_print_jnode>
if ( the_jnode->type == IMFS_DIRECTORY )
ffc074e4: 80 1b 00 4c lwz r0,76(r27)
ffc074e8: 2f 80 00 01 cmpwi cr7,r0,1
ffc074ec: 41 9e 00 48 beq- cr7,ffc07534 <IMFS_dump_directory+0xe4>
the_chain = &the_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 ) {
ffc074f0: 83 7b 00 00 lwz r27,0(r27)
IMFS_assert( level >= 0 );
IMFS_assert( the_directory->type == IMFS_DIRECTORY );
the_chain = &the_directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
ffc074f4: 7f 9b d0 00 cmpw cr7,r27,r26
ffc074f8: 40 9e ff b4 bne+ cr7,ffc074ac <IMFS_dump_directory+0x5c>
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
if ( the_jnode->type == IMFS_DIRECTORY )
IMFS_dump_directory( the_jnode, level + 1 );
}
}
ffc074fc: 80 01 00 34 lwz r0,52(r1)
ffc07500: 81 81 00 0c lwz r12,12(r1)
ffc07504: 7c 08 03 a6 mtlr r0
ffc07508: 83 01 00 10 lwz r24,16(r1)
ffc0750c: 83 21 00 14 lwz r25,20(r1)
ffc07510: 7d 80 81 20 mtcrf 8,r12
ffc07514: 83 41 00 18 lwz r26,24(r1)
ffc07518: 83 61 00 1c lwz r27,28(r1)
ffc0751c: 83 81 00 20 lwz r28,32(r1)
ffc07520: 83 a1 00 24 lwz r29,36(r1)
ffc07524: 83 c1 00 28 lwz r30,40(r1)
ffc07528: 83 e1 00 2c lwz r31,44(r1)
ffc0752c: 38 21 00 30 addi r1,r1,48
ffc07530: 4e 80 00 20 blr
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
if ( the_jnode->type == IMFS_DIRECTORY )
IMFS_dump_directory( the_jnode, level + 1 );
ffc07534: 7f 63 db 78 mr r3,r27
ffc07538: 7f 04 c3 78 mr r4,r24
ffc0753c: 4b ff ff 15 bl ffc07450 <IMFS_dump_directory>
ffc07540: 4b ff ff b0 b ffc074f0 <IMFS_dump_directory+0xa0>
ffc0e310 <IMFS_eval_path>:
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
ffc0e310: 94 21 ff a8 stwu r1,-88(r1)
ffc0e314: 7c 08 02 a6 mflr r0
ffc0e318: 90 01 00 5c stw r0,92(r1)
IMFS_token_types type = IMFS_CURRENT_DIR;
char token[ IMFS_NAME_MAX + 1 ];
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
ffc0e31c: 54 a0 00 39 rlwinm. r0,r5,0,0,28
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
int i = 0;
ffc0e320: 38 00 00 00 li r0,0
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
ffc0e324: 93 81 00 48 stw r28,72(r1)
ffc0e328: 7c bc 2b 78 mr r28,r5
ffc0e32c: 93 a1 00 4c stw r29,76(r1)
ffc0e330: 7c 7d 1b 78 mr r29,r3
ffc0e334: 93 e1 00 54 stw r31,84(r1)
ffc0e338: 7c df 33 78 mr r31,r6
ffc0e33c: 93 41 00 40 stw r26,64(r1)
ffc0e340: 93 61 00 44 stw r27,68(r1)
ffc0e344: 93 c1 00 50 stw r30,80(r1)
ffc0e348: 90 81 00 38 stw r4,56(r1)
int i = 0;
ffc0e34c: 90 01 00 0c stw r0,12(r1)
IMFS_token_types type = IMFS_CURRENT_DIR;
char token[ IMFS_NAME_MAX + 1 ];
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
ffc0e350: 40 82 03 28 bne- ffc0e678 <IMFS_eval_path+0x368> <== NEVER TAKEN
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
ffc0e354: 83 c6 00 00 lwz r30,0(r6)
ffc0e358: 38 60 00 00 li r3,0
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
ffc0e35c: 3f 60 00 00 lis r27,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 );
ffc0e360: 7c 7d 1a 14 add r3,r29,r3
ffc0e364: 38 a1 00 10 addi r5,r1,16
ffc0e368: 38 c1 00 08 addi r6,r1,8
ffc0e36c: 48 00 0b 7d bl ffc0eee8 <IMFS_get_token>
pathnamelen -= len;
ffc0e370: 80 01 00 08 lwz r0,8(r1)
* 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 );
ffc0e374: 7c 7a 1b 78 mr r26,r3
pathnamelen -= len;
i += len;
if ( !pathloc->node_access )
ffc0e378: 80 7f 00 00 lwz r3,0(r31)
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
pathnamelen -= len;
ffc0e37c: 80 81 00 38 lwz r4,56(r1)
i += len;
if ( !pathloc->node_access )
ffc0e380: 2f 83 00 00 cmpwi cr7,r3,0
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
pathnamelen -= len;
i += len;
ffc0e384: 81 21 00 0c lwz r9,12(r1)
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
pathnamelen -= len;
ffc0e388: 7c 80 20 50 subf r4,r0,r4
i += len;
ffc0e38c: 7c 09 02 14 add r0,r9,r0
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
pathnamelen -= len;
ffc0e390: 90 81 00 38 stw r4,56(r1)
i += len;
ffc0e394: 90 01 00 0c stw r0,12(r1)
if ( !pathloc->node_access )
ffc0e398: 41 9e 02 cc beq- cr7,ffc0e664 <IMFS_eval_path+0x354> <== 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 )
ffc0e39c: 2f 9a 00 00 cmpwi cr7,r26,0
ffc0e3a0: 40 9e 00 44 bne- cr7,ffc0e3e4 <IMFS_eval_path+0xd4>
* 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 ) {
ffc0e3a4: 80 03 00 4c lwz r0,76(r3)
ffc0e3a8: 2f 80 00 01 cmpwi cr7,r0,1
ffc0e3ac: 41 9e 01 a8 beq- cr7,ffc0e554 <IMFS_eval_path+0x244>
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
ffc0e3b0: 7f e3 fb 78 mr r3,r31
ffc0e3b4: 4b ff fd c9 bl ffc0e17c <IMFS_Set_handlers>
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
ffc0e3b8: 7f 84 e3 78 mr r4,r28
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
ffc0e3bc: 7c 7e 1b 78 mr r30,r3
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
ffc0e3c0: 7f e3 fb 78 mr r3,r31
ffc0e3c4: 4b ff fe 45 bl ffc0e208 <IMFS_evaluate_permission>
ffc0e3c8: 2f 83 00 00 cmpwi cr7,r3,0
ffc0e3cc: 40 be 00 e4 bne+ cr7,ffc0e4b0 <IMFS_eval_path+0x1a0>
rtems_set_errno_and_return_minus_one( EACCES );
ffc0e3d0: 48 00 59 bd bl ffc13d8c <__errno>
ffc0e3d4: 38 00 00 0d li r0,13
ffc0e3d8: 90 03 00 00 stw r0,0(r3)
ffc0e3dc: 3b c0 ff ff li r30,-1
ffc0e3e0: 48 00 00 d0 b ffc0e4b0 <IMFS_eval_path+0x1a0>
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
ffc0e3e4: 80 1e 00 4c lwz r0,76(r30)
ffc0e3e8: 2f 80 00 01 cmpwi cr7,r0,1
ffc0e3ec: 41 9e 00 f0 beq- cr7,ffc0e4dc <IMFS_eval_path+0x1cc>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
switch( type ) {
ffc0e3f0: 2f 9a 00 03 cmpwi cr7,r26,3
ffc0e3f4: 41 9e 00 28 beq- cr7,ffc0e41c <IMFS_eval_path+0x10c>
ffc0e3f8: 2f 9a 00 04 cmpwi cr7,r26,4
ffc0e3fc: 41 9e 00 a4 beq- cr7,ffc0e4a0 <IMFS_eval_path+0x190>
ffc0e400: 2f 1a 00 02 cmpwi cr6,r26,2
ffc0e404: 41 9a 00 60 beq- cr6,ffc0e464 <IMFS_eval_path+0x154>
/*
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
ffc0e408: 41 be ff 9c beq- cr7,ffc0e3a4 <IMFS_eval_path+0x94> <== NEVER TAKEN
ffc0e40c: 7c 7e 1b 78 mr r30,r3
ffc0e410: 80 81 00 38 lwz r4,56(r1)
ffc0e414: 80 61 00 0c lwz r3,12(r1)
ffc0e418: 4b ff ff 48 b ffc0e360 <IMFS_eval_path+0x50>
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
ffc0e41c: 80 03 00 4c lwz r0,76(r3)
ffc0e420: 2f 80 00 03 cmpwi cr7,r0,3
ffc0e424: 41 9e 01 80 beq- cr7,ffc0e5a4 <IMFS_eval_path+0x294>
* It would be a design error if we evaluated the link and
* was broken.
*/
IMFS_assert( node );
} else if ( node->type == IMFS_SYM_LINK ) {
ffc0e428: 2f 80 00 04 cmpwi cr7,r0,4
ffc0e42c: 41 9e 02 14 beq- cr7,ffc0e640 <IMFS_eval_path+0x330>
}
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
ffc0e430: 2f 80 00 01 cmpwi cr7,r0,1
ffc0e434: 40 9e 02 58 bne- cr7,ffc0e68c <IMFS_eval_path+0x37c>
rtems_set_errno_and_return_minus_one( ENOTDIR );
/*
* Find the token name in the current node.
*/
node = IMFS_find_match_in_dir( node, token );
ffc0e438: 38 81 00 10 addi r4,r1,16
ffc0e43c: 48 00 09 a9 bl ffc0ede4 <IMFS_find_match_in_dir>
if ( !node )
ffc0e440: 7c 7e 1b 79 mr. r30,r3
ffc0e444: 41 82 02 20 beq- ffc0e664 <IMFS_eval_path+0x354>
* file system and not the IMFS. For example the IMFS length is
* limited. If the token is a parent directory move back up otherwise
* set loc to the new fs root node and let them finish evaluating the
* path.
*/
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
ffc0e448: 80 1e 00 4c lwz r0,76(r30)
ffc0e44c: 80 81 00 38 lwz r4,56(r1)
ffc0e450: 2f 80 00 01 cmpwi cr7,r0,1
ffc0e454: 41 9e 00 a4 beq- cr7,ffc0e4f8 <IMFS_eval_path+0x1e8>
}
/*
* Set the node access to the point we have found.
*/
pathloc->node_access = node;
ffc0e458: 93 df 00 00 stw r30,0(r31)
/*
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
ffc0e45c: 80 61 00 0c lwz r3,12(r1)
ffc0e460: 4b ff ff 00 b ffc0e360 <IMFS_eval_path+0x50>
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
ffc0e464: 81 3b 27 7c lwz r9,10108(r27)
ffc0e468: 80 09 00 18 lwz r0,24(r9)
ffc0e46c: 7f 80 18 00 cmpw cr7,r0,r3
ffc0e470: 41 9e 01 24 beq- cr7,ffc0e594 <IMFS_eval_path+0x284>
if ( !IMFS_evaluate_permission( pathloc, flags ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
ffc0e474: 81 5f 00 10 lwz r10,16(r31)
/*
* Am I at the root of this mounted filesystem?
*/
if ( rtems_filesystem_is_root_location( pathloc ) ) {
ffc0e478: 80 0a 00 1c lwz r0,28(r10)
ffc0e47c: 7f 80 18 00 cmpw cr7,r0,r3
ffc0e480: 41 9e 01 3c beq- cr7,ffc0e5bc <IMFS_eval_path+0x2ac>
pathnamelen+len,
flags,pathloc);
}
} else {
if ( !node->Parent )
ffc0e484: 83 c3 00 08 lwz r30,8(r3)
ffc0e488: 2f 9e 00 00 cmpwi cr7,r30,0
ffc0e48c: 41 9e 02 14 beq- cr7,ffc0e6a0 <IMFS_eval_path+0x390>
rtems_set_errno_and_return_minus_one( ENOENT );
node = node->Parent;
pathloc->node_access = node;
ffc0e490: 93 df 00 00 stw r30,0(r31)
ffc0e494: 80 81 00 38 lwz r4,56(r1)
/*
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
ffc0e498: 80 61 00 0c lwz r3,12(r1)
ffc0e49c: 4b ff fe c4 b ffc0e360 <IMFS_eval_path+0x50>
case IMFS_NO_MORE_PATH:
case IMFS_CURRENT_DIR:
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
ffc0e4a0: 48 00 58 ed bl ffc13d8c <__errno>
ffc0e4a4: 38 00 00 5b li r0,91
ffc0e4a8: 90 03 00 00 stw r0,0(r3)
ffc0e4ac: 3b c0 ff ff li r30,-1
if ( !IMFS_evaluate_permission( pathloc, flags ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
ffc0e4b0: 80 01 00 5c lwz r0,92(r1)
ffc0e4b4: 7f c3 f3 78 mr r3,r30
ffc0e4b8: 83 41 00 40 lwz r26,64(r1)
ffc0e4bc: 7c 08 03 a6 mtlr r0
ffc0e4c0: 83 61 00 44 lwz r27,68(r1)
ffc0e4c4: 83 81 00 48 lwz r28,72(r1)
ffc0e4c8: 83 a1 00 4c lwz r29,76(r1)
ffc0e4cc: 83 c1 00 50 lwz r30,80(r1)
ffc0e4d0: 83 e1 00 54 lwz r31,84(r1)
ffc0e4d4: 38 21 00 58 addi r1,r1,88
ffc0e4d8: 4e 80 00 20 blr
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
ffc0e4dc: 7f e3 fb 78 mr r3,r31
ffc0e4e0: 38 80 00 01 li r4,1
ffc0e4e4: 4b ff fd 25 bl ffc0e208 <IMFS_evaluate_permission>
ffc0e4e8: 2f 83 00 00 cmpwi cr7,r3,0
ffc0e4ec: 41 be fe e4 beq- cr7,ffc0e3d0 <IMFS_eval_path+0xc0>
ffc0e4f0: 80 7f 00 00 lwz r3,0(r31)
ffc0e4f4: 4b ff fe fc b ffc0e3f0 <IMFS_eval_path+0xe0>
* file system and not the IMFS. For example the IMFS length is
* limited. If the token is a parent directory move back up otherwise
* set loc to the new fs root node and let them finish evaluating the
* path.
*/
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
ffc0e4f8: 80 1e 00 5c lwz r0,92(r30)
ffc0e4fc: 2f 80 00 00 cmpwi cr7,r0,0
ffc0e500: 41 be ff 58 beq- cr7,ffc0e458 <IMFS_eval_path+0x148>
IMFS_skip_separator( pathname, &pathnamelen, &i);
ffc0e504: 7f a3 eb 78 mr r3,r29
ffc0e508: 38 81 00 38 addi r4,r1,56
ffc0e50c: 38 a1 00 0c addi r5,r1,12
ffc0e510: 4b ff fb e5 bl ffc0e0f4 <IMFS_skip_separator>
if ((pathname[i] != '.') || (pathname[i + 1] != '.')) {
ffc0e514: 81 21 00 0c lwz r9,12(r1)
ffc0e518: 7c 1d 48 ae lbzx r0,r29,r9
ffc0e51c: 7c 7d 4a 14 add r3,r29,r9
ffc0e520: 2f 80 00 2e cmpwi cr7,r0,46
ffc0e524: 40 9e 01 8c bne- cr7,ffc0e6b0 <IMFS_eval_path+0x3a0>
ffc0e528: 88 03 00 01 lbz r0,1(r3)
ffc0e52c: 2f 80 00 2e cmpwi cr7,r0,46
ffc0e530: 40 9e 01 80 bne- cr7,ffc0e6b0 <IMFS_eval_path+0x3a0>
return (*pathloc->ops->evalpath_h)( &pathname[i],
pathnamelen,
flags, pathloc );
}
i += 2;
pathnamelen -= 2;
ffc0e534: 80 81 00 38 lwz r4,56(r1)
*pathloc = node->info.directory.mt_fs->mt_fs_root;
return (*pathloc->ops->evalpath_h)( &pathname[i],
pathnamelen,
flags, pathloc );
}
i += 2;
ffc0e538: 39 29 00 02 addi r9,r9,2
pathnamelen -= 2;
node = node->Parent;
ffc0e53c: 83 de 00 08 lwz r30,8(r30)
return (*pathloc->ops->evalpath_h)( &pathname[i],
pathnamelen,
flags, pathloc );
}
i += 2;
pathnamelen -= 2;
ffc0e540: 38 84 ff fe addi r4,r4,-2
*pathloc = node->info.directory.mt_fs->mt_fs_root;
return (*pathloc->ops->evalpath_h)( &pathname[i],
pathnamelen,
flags, pathloc );
}
i += 2;
ffc0e544: 91 21 00 0c stw r9,12(r1)
pathnamelen -= 2;
ffc0e548: 90 81 00 38 stw r4,56(r1)
}
/*
* Set the node access to the point we have found.
*/
pathloc->node_access = node;
ffc0e54c: 93 df 00 00 stw r30,0(r31)
ffc0e550: 4b ff ff 0c b ffc0e45c <IMFS_eval_path+0x14c>
*
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
ffc0e554: 81 43 00 5c lwz r10,92(r3)
ffc0e558: 2f 8a 00 00 cmpwi cr7,r10,0
ffc0e55c: 41 be fe 54 beq- cr7,ffc0e3b0 <IMFS_eval_path+0xa0> <== ALWAYS TAKEN
*pathloc = node->info.directory.mt_fs->mt_fs_root;
ffc0e560: 81 2a 00 20 lwz r9,32(r10) <== NOT EXECUTED
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
ffc0e564: 7f 85 e3 78 mr r5,r28 <== NOT EXECUTED
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
*pathloc = node->info.directory.mt_fs->mt_fs_root;
ffc0e568: 80 0a 00 24 lwz r0,36(r10) <== NOT EXECUTED
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
ffc0e56c: 7f e6 fb 78 mr r6,r31 <== NOT EXECUTED
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
*pathloc = node->info.directory.mt_fs->mt_fs_root;
ffc0e570: 81 6a 00 28 lwz r11,40(r10) <== NOT EXECUTED
ffc0e574: 81 0a 00 1c lwz r8,28(r10) <== NOT EXECUTED
ffc0e578: 91 3f 00 04 stw r9,4(r31) <== NOT EXECUTED
ffc0e57c: 91 1f 00 00 stw r8,0(r31) <== NOT EXECUTED
ffc0e580: 90 1f 00 08 stw r0,8(r31) <== NOT EXECUTED
ffc0e584: 91 7f 00 0c stw r11,12(r31) <== NOT EXECUTED
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
ffc0e588: 81 21 00 08 lwz r9,8(r1) <== NOT EXECUTED
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
*pathloc = node->info.directory.mt_fs->mt_fs_root;
ffc0e58c: 80 0a 00 2c lwz r0,44(r10) <== NOT EXECUTED
ffc0e590: 48 00 00 5c b ffc0e5ec <IMFS_eval_path+0x2dc> <== 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 )
ffc0e594: 7c 7e 1b 78 mr r30,r3
ffc0e598: 80 81 00 38 lwz r4,56(r1)
/*
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
ffc0e59c: 80 61 00 0c lwz r3,12(r1)
ffc0e5a0: 4b ff fd c0 b ffc0e360 <IMFS_eval_path+0x50>
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
IMFS_evaluate_hard_link( pathloc, 0 );
ffc0e5a4: 7f e3 fb 78 mr r3,r31
ffc0e5a8: 38 80 00 00 li r4,0
ffc0e5ac: 4b ff fc fd bl ffc0e2a8 <IMFS_evaluate_hard_link>
node = pathloc->node_access;
ffc0e5b0: 80 7f 00 00 lwz r3,0(r31)
ffc0e5b4: 80 03 00 4c lwz r0,76(r3)
ffc0e5b8: 4b ff fe 78 b ffc0e430 <IMFS_eval_path+0x120>
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break; /* Throw out the .. in this case */
} else {
*pathloc = pathloc->mt_entry->mt_point_node;
ffc0e5bc: 81 2a 00 0c lwz r9,12(r10)
return (*pathloc->ops->evalpath_h)(&(pathname[i-len]),
ffc0e5c0: 7f 85 e3 78 mr r5,r28
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break; /* Throw out the .. in this case */
} else {
*pathloc = pathloc->mt_entry->mt_point_node;
ffc0e5c4: 80 0a 00 10 lwz r0,16(r10)
return (*pathloc->ops->evalpath_h)(&(pathname[i-len]),
ffc0e5c8: 7f e6 fb 78 mr r6,r31
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break; /* Throw out the .. in this case */
} else {
*pathloc = pathloc->mt_entry->mt_point_node;
ffc0e5cc: 81 6a 00 14 lwz r11,20(r10)
ffc0e5d0: 81 0a 00 08 lwz r8,8(r10)
ffc0e5d4: 91 3f 00 04 stw r9,4(r31)
ffc0e5d8: 91 1f 00 00 stw r8,0(r31)
ffc0e5dc: 90 1f 00 08 stw r0,8(r31)
ffc0e5e0: 91 7f 00 0c stw r11,12(r31)
return (*pathloc->ops->evalpath_h)(&(pathname[i-len]),
ffc0e5e4: 81 21 00 08 lwz r9,8(r1)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break; /* Throw out the .. in this case */
} else {
*pathloc = pathloc->mt_entry->mt_point_node;
ffc0e5e8: 80 0a 00 18 lwz r0,24(r10)
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
*pathloc = node->info.directory.mt_fs->mt_fs_root;
ffc0e5ec: 90 1f 00 10 stw r0,16(r31)
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
ffc0e5f0: 80 61 00 0c lwz r3,12(r1)
ffc0e5f4: 80 0b 00 00 lwz r0,0(r11)
ffc0e5f8: 80 81 00 38 lwz r4,56(r1)
ffc0e5fc: 7c 69 18 50 subf r3,r9,r3
ffc0e600: 7c 7d 1a 14 add r3,r29,r3
ffc0e604: 7c 09 03 a6 mtctr r0
ffc0e608: 7c 89 22 14 add r4,r9,r4
ffc0e60c: 4e 80 04 21 bctrl
if ( !IMFS_evaluate_permission( pathloc, flags ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
ffc0e610: 80 01 00 5c lwz r0,92(r1)
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
*pathloc = node->info.directory.mt_fs->mt_fs_root;
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
ffc0e614: 7c 7e 1b 78 mr r30,r3
if ( !IMFS_evaluate_permission( pathloc, flags ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
ffc0e618: 83 41 00 40 lwz r26,64(r1)
ffc0e61c: 7c 08 03 a6 mtlr r0
ffc0e620: 7f c3 f3 78 mr r3,r30
ffc0e624: 83 61 00 44 lwz r27,68(r1)
ffc0e628: 83 81 00 48 lwz r28,72(r1)
ffc0e62c: 83 a1 00 4c lwz r29,76(r1)
ffc0e630: 83 c1 00 50 lwz r30,80(r1)
ffc0e634: 83 e1 00 54 lwz r31,84(r1)
ffc0e638: 38 21 00 58 addi r1,r1,88
ffc0e63c: 4e 80 00 20 blr
* was broken.
*/
IMFS_assert( node );
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_sym_link( pathloc, 0 );
ffc0e640: 7f e3 fb 78 mr r3,r31
ffc0e644: 38 80 00 00 li r4,0
ffc0e648: 48 00 00 b5 bl ffc0e6fc <IMFS_evaluate_sym_link>
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
if ( result == -1 )
ffc0e64c: 2f 83 ff ff cmpwi cr7,r3,-1
* was broken.
*/
IMFS_assert( node );
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_sym_link( pathloc, 0 );
ffc0e650: 7c 7e 1b 78 mr r30,r3
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
ffc0e654: 80 7f 00 00 lwz r3,0(r31)
if ( result == -1 )
ffc0e658: 41 be fe 58 beq- cr7,ffc0e4b0 <IMFS_eval_path+0x1a0> <== NEVER TAKEN
ffc0e65c: 80 03 00 4c lwz r0,76(r3)
ffc0e660: 4b ff fd d0 b ffc0e430 <IMFS_eval_path+0x120>
/*
* Find the token name in the current node.
*/
node = IMFS_find_match_in_dir( node, token );
if ( !node )
rtems_set_errno_and_return_minus_one( ENOENT );
ffc0e664: 48 00 57 29 bl ffc13d8c <__errno>
ffc0e668: 38 00 00 02 li r0,2
ffc0e66c: 90 03 00 00 stw r0,0(r3)
ffc0e670: 3b c0 ff ff li r30,-1
ffc0e674: 4b ff fe 3c b ffc0e4b0 <IMFS_eval_path+0x1a0>
char token[ IMFS_NAME_MAX + 1 ];
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
rtems_set_errno_and_return_minus_one( EIO );
ffc0e678: 48 00 57 15 bl ffc13d8c <__errno> <== NOT EXECUTED
ffc0e67c: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc0e680: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc0e684: 3b c0 ff ff li r30,-1 <== NOT EXECUTED
ffc0e688: 4b ff fe 28 b ffc0e4b0 <IMFS_eval_path+0x1a0> <== NOT EXECUTED
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
ffc0e68c: 48 00 57 01 bl ffc13d8c <__errno>
ffc0e690: 38 00 00 14 li r0,20
ffc0e694: 90 03 00 00 stw r0,0(r3)
ffc0e698: 3b c0 ff ff li r30,-1
ffc0e69c: 4b ff fe 14 b ffc0e4b0 <IMFS_eval_path+0x1a0>
flags,pathloc);
}
} else {
if ( !node->Parent )
rtems_set_errno_and_return_minus_one( ENOENT );
ffc0e6a0: 48 00 56 ed bl ffc13d8c <__errno>
ffc0e6a4: 3b c0 ff ff li r30,-1
ffc0e6a8: 93 43 00 00 stw r26,0(r3)
ffc0e6ac: 4b ff fe 04 b ffc0e4b0 <IMFS_eval_path+0x1a0>
* path.
*/
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
IMFS_skip_separator( pathname, &pathnamelen, &i);
if ((pathname[i] != '.') || (pathname[i + 1] != '.')) {
*pathloc = node->info.directory.mt_fs->mt_fs_root;
ffc0e6b0: 81 3e 00 5c lwz r9,92(r30)
return (*pathloc->ops->evalpath_h)( &pathname[i],
ffc0e6b4: 7f 85 e3 78 mr r5,r28
ffc0e6b8: 7f e6 fb 78 mr r6,r31
ffc0e6bc: 80 81 00 38 lwz r4,56(r1)
* path.
*/
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
IMFS_skip_separator( pathname, &pathnamelen, &i);
if ((pathname[i] != '.') || (pathname[i + 1] != '.')) {
*pathloc = node->info.directory.mt_fs->mt_fs_root;
ffc0e6c0: 81 69 00 28 lwz r11,40(r9)
ffc0e6c4: 80 09 00 24 lwz r0,36(r9)
ffc0e6c8: 81 09 00 1c lwz r8,28(r9)
ffc0e6cc: 81 49 00 20 lwz r10,32(r9)
ffc0e6d0: 90 1f 00 08 stw r0,8(r31)
ffc0e6d4: 91 1f 00 00 stw r8,0(r31)
ffc0e6d8: 91 5f 00 04 stw r10,4(r31)
ffc0e6dc: 91 7f 00 0c stw r11,12(r31)
return (*pathloc->ops->evalpath_h)( &pathname[i],
ffc0e6e0: 80 0b 00 00 lwz r0,0(r11)
* path.
*/
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
IMFS_skip_separator( pathname, &pathnamelen, &i);
if ((pathname[i] != '.') || (pathname[i + 1] != '.')) {
*pathloc = node->info.directory.mt_fs->mt_fs_root;
ffc0e6e4: 81 29 00 2c lwz r9,44(r9)
return (*pathloc->ops->evalpath_h)( &pathname[i],
ffc0e6e8: 7c 09 03 a6 mtctr r0
* path.
*/
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
IMFS_skip_separator( pathname, &pathnamelen, &i);
if ((pathname[i] != '.') || (pathname[i + 1] != '.')) {
*pathloc = node->info.directory.mt_fs->mt_fs_root;
ffc0e6ec: 91 3f 00 10 stw r9,16(r31)
return (*pathloc->ops->evalpath_h)( &pathname[i],
ffc0e6f0: 4e 80 04 21 bctrl
ffc0e6f4: 7c 7e 1b 78 mr r30,r3
ffc0e6f8: 4b ff fd b8 b ffc0e4b0 <IMFS_eval_path+0x1a0>
ffc0e8c8 <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 */
)
{
ffc0e8c8: 94 21 ff a8 stwu r1,-88(r1)
ffc0e8cc: 7c 08 02 a6 mflr r0
ffc0e8d0: 7d 80 00 26 mfcr r12
ffc0e8d4: 90 01 00 5c stw r0,92(r1)
int i = 0;
ffc0e8d8: 38 00 00 00 li r0,0
int IMFS_evaluate_for_make(
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
ffc0e8dc: 93 61 00 44 stw r27,68(r1)
ffc0e8e0: 7c bb 2b 78 mr r27,r5
ffc0e8e4: 93 81 00 48 stw r28,72(r1)
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
ffc0e8e8: 3f 80 00 00 lis r28,0
int IMFS_evaluate_for_make(
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
ffc0e8ec: 93 a1 00 4c stw r29,76(r1)
ffc0e8f0: 7c 7d 1b 78 mr r29,r3
ffc0e8f4: 93 c1 00 50 stw r30,80(r1)
ffc0e8f8: 93 e1 00 54 stw r31,84(r1)
ffc0e8fc: 7c 9f 23 78 mr r31,r4
int i = 0;
ffc0e900: 90 01 00 10 stw r0,16(r1)
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
ffc0e904: 83 c4 00 00 lwz r30,0(r4)
int IMFS_evaluate_for_make(
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
ffc0e908: 93 41 00 40 stw r26,64(r1)
ffc0e90c: 91 81 00 3c stw r12,60(r1)
node = pathloc->node_access;
/*
* Get the path length.
*/
pathlen = strlen( path );
ffc0e910: 48 00 6d a9 bl ffc156b8 <strlen>
ffc0e914: 7c 64 1b 78 mr r4,r3
ffc0e918: 90 61 00 08 stw r3,8(r1)
ffc0e91c: 38 00 00 00 li r0,0
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
ffc0e920: 7c 7d 02 14 add r3,r29,r0
ffc0e924: 38 a1 00 14 addi r5,r1,20
ffc0e928: 38 c1 00 0c addi r6,r1,12
ffc0e92c: 48 00 05 bd bl ffc0eee8 <IMFS_get_token>
pathlen -= len;
ffc0e930: 80 01 00 0c lwz r0,12(r1)
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
ffc0e934: 7c 7a 1b 78 mr r26,r3
pathlen -= len;
i += len;
if ( !pathloc->node_access )
ffc0e938: 80 7f 00 00 lwz r3,0(r31)
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
ffc0e93c: 81 21 00 08 lwz r9,8(r1)
i += len;
if ( !pathloc->node_access )
ffc0e940: 2f 83 00 00 cmpwi cr7,r3,0
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
i += len;
ffc0e944: 81 61 00 10 lwz r11,16(r1)
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
ffc0e948: 7d 20 48 50 subf r9,r0,r9
i += len;
ffc0e94c: 7c 0b 02 14 add r0,r11,r0
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
ffc0e950: 91 21 00 08 stw r9,8(r1)
i += len;
ffc0e954: 90 01 00 10 stw r0,16(r1)
if ( !pathloc->node_access )
ffc0e958: 41 9e 02 54 beq- cr7,ffc0ebac <IMFS_evaluate_for_make+0x2e4><== NEVER TAKEN
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
ffc0e95c: 2e 1a 00 00 cmpwi cr4,r26,0
ffc0e960: 40 92 00 48 bne- cr4,ffc0e9a8 <IMFS_evaluate_for_make+0xe0>
pathloc->node_access = node;
}
break;
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
ffc0e964: 48 00 54 29 bl ffc13d8c <__errno>
ffc0e968: 38 00 00 11 li r0,17
ffc0e96c: 90 03 00 00 stw r0,0(r3)
ffc0e970: 3b c0 ff ff li r30,-1
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
ffc0e974: 80 01 00 5c lwz r0,92(r1)
ffc0e978: 7f c3 f3 78 mr r3,r30
ffc0e97c: 81 81 00 3c lwz r12,60(r1)
ffc0e980: 7c 08 03 a6 mtlr r0
ffc0e984: 83 41 00 40 lwz r26,64(r1)
ffc0e988: 83 61 00 44 lwz r27,68(r1)
ffc0e98c: 7d 80 81 20 mtcrf 8,r12
ffc0e990: 83 81 00 48 lwz r28,72(r1)
ffc0e994: 83 a1 00 4c lwz r29,76(r1)
ffc0e998: 83 c1 00 50 lwz r30,80(r1)
ffc0e99c: 83 e1 00 54 lwz r31,84(r1)
ffc0e9a0: 38 21 00 58 addi r1,r1,88
ffc0e9a4: 4e 80 00 20 blr
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
ffc0e9a8: 80 1e 00 4c lwz r0,76(r30)
ffc0e9ac: 2f 80 00 01 cmpwi cr7,r0,1
ffc0e9b0: 41 9e 01 1c beq- cr7,ffc0eacc <IMFS_evaluate_for_make+0x204>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
switch( type ) {
ffc0e9b4: 2f 9a 00 02 cmpwi cr7,r26,2
ffc0e9b8: 41 9e 00 84 beq- cr7,ffc0ea3c <IMFS_evaluate_for_make+0x174>
ffc0e9bc: 2b 9a 00 02 cmplwi cr7,r26,2
ffc0e9c0: 40 9d 00 24 ble- cr7,ffc0e9e4 <IMFS_evaluate_for_make+0x11c>
ffc0e9c4: 2f 9a 00 03 cmpwi cr7,r26,3
ffc0e9c8: 41 9e 00 b0 beq- cr7,ffc0ea78 <IMFS_evaluate_for_make+0x1b0>
ffc0e9cc: 2f 9a 00 04 cmpwi cr7,r26,4
ffc0e9d0: 41 9e 00 28 beq- cr7,ffc0e9f8 <IMFS_evaluate_for_make+0x130><== ALWAYS TAKEN
ffc0e9d4: 80 01 00 10 lwz r0,16(r1) <== NOT EXECUTED
ffc0e9d8: 7c 7e 1b 78 mr r30,r3 <== NOT EXECUTED
ffc0e9dc: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
ffc0e9e0: 4b ff ff 40 b ffc0e920 <IMFS_evaluate_for_make+0x58> <== NOT EXECUTED
ffc0e9e4: 41 b2 ff 80 beq- cr4,ffc0e964 <IMFS_evaluate_for_make+0x9c><== NEVER TAKEN
ffc0e9e8: 80 01 00 10 lwz r0,16(r1)
ffc0e9ec: 7c 7e 1b 78 mr r30,r3
ffc0e9f0: 80 81 00 08 lwz r4,8(r1)
ffc0e9f4: 4b ff ff 2c b ffc0e920 <IMFS_evaluate_for_make+0x58>
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
ffc0e9f8: 48 00 53 95 bl ffc13d8c <__errno>
ffc0e9fc: 38 00 00 5b li r0,91
ffc0ea00: 90 03 00 00 stw r0,0(r3)
ffc0ea04: 3b c0 ff ff li r30,-1
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
ffc0ea08: 7f c3 f3 78 mr r3,r30
ffc0ea0c: 80 01 00 5c lwz r0,92(r1)
ffc0ea10: 81 81 00 3c lwz r12,60(r1)
ffc0ea14: 7c 08 03 a6 mtlr r0
ffc0ea18: 83 41 00 40 lwz r26,64(r1)
ffc0ea1c: 83 61 00 44 lwz r27,68(r1)
ffc0ea20: 7d 80 81 20 mtcrf 8,r12
ffc0ea24: 83 81 00 48 lwz r28,72(r1)
ffc0ea28: 83 a1 00 4c lwz r29,76(r1)
ffc0ea2c: 83 c1 00 50 lwz r30,80(r1)
ffc0ea30: 83 e1 00 54 lwz r31,84(r1)
ffc0ea34: 38 21 00 58 addi r1,r1,88
ffc0ea38: 4e 80 00 20 blr
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
ffc0ea3c: 81 3c 27 7c lwz r9,10108(r28)
ffc0ea40: 83 c9 00 18 lwz r30,24(r9)
ffc0ea44: 7f 9e 18 00 cmpw cr7,r30,r3
ffc0ea48: 41 9e 01 78 beq- cr7,ffc0ebc0 <IMFS_evaluate_for_make+0x2f8>
if ( !IMFS_evaluate_permission( pathloc, flags ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
ffc0ea4c: 81 7f 00 10 lwz r11,16(r31)
/*
* Am I at the root of this mounted filesystem?
*/
if ( rtems_filesystem_is_root_location( pathloc ) ) {
ffc0ea50: 80 0b 00 1c lwz r0,28(r11)
ffc0ea54: 7f 83 00 00 cmpw cr7,r3,r0
ffc0ea58: 41 9e 01 74 beq- cr7,ffc0ebcc <IMFS_evaluate_for_make+0x304>
*pathloc = pathloc->mt_entry->mt_point_node;
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
}
} else {
if ( !node->Parent )
ffc0ea5c: 83 c3 00 08 lwz r30,8(r3)
ffc0ea60: 2f 9e 00 00 cmpwi cr7,r30,0
ffc0ea64: 41 9e 02 14 beq- cr7,ffc0ec78 <IMFS_evaluate_for_make+0x3b0>
rtems_set_errno_and_return_minus_one( ENOENT );
node = node->Parent;
}
pathloc->node_access = node;
ffc0ea68: 93 df 00 00 stw r30,0(r31)
ffc0ea6c: 80 01 00 10 lwz r0,16(r1)
ffc0ea70: 80 81 00 08 lwz r4,8(r1)
break;
ffc0ea74: 4b ff fe ac b ffc0e920 <IMFS_evaluate_for_make+0x58>
case IMFS_NAME:
if ( node->type == IMFS_HARD_LINK ) {
ffc0ea78: 80 03 00 4c lwz r0,76(r3)
ffc0ea7c: 2f 80 00 03 cmpwi cr7,r0,3
ffc0ea80: 41 9e 00 68 beq- cr7,ffc0eae8 <IMFS_evaluate_for_make+0x220>
result = IMFS_evaluate_link( pathloc, 0 );
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
ffc0ea84: 2f 80 00 04 cmpwi cr7,r0,4
ffc0ea88: 41 9e 00 60 beq- cr7,ffc0eae8 <IMFS_evaluate_for_make+0x220>
if ( result == -1 )
return -1;
}
node = pathloc->node_access;
if ( !node )
ffc0ea8c: 2f 83 00 00 cmpwi cr7,r3,0
ffc0ea90: 41 9e 01 d4 beq- cr7,ffc0ec64 <IMFS_evaluate_for_make+0x39c><== NEVER TAKEN
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
ffc0ea94: 80 03 00 4c lwz r0,76(r3)
ffc0ea98: 2f 80 00 01 cmpwi cr7,r0,1
ffc0ea9c: 40 9e 01 c8 bne- cr7,ffc0ec64 <IMFS_evaluate_for_make+0x39c>
/*
* Find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
ffc0eaa0: 38 81 00 14 addi r4,r1,20
ffc0eaa4: 48 00 03 41 bl ffc0ede4 <IMFS_find_match_in_dir>
/*
* If there is no node we have found the name of the node we
* wish to create.
*/
if ( ! node )
ffc0eaa8: 7c 7e 1b 79 mr. r30,r3
ffc0eaac: 41 82 00 b8 beq- ffc0eb64 <IMFS_evaluate_for_make+0x29c>
done = true;
else {
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
ffc0eab0: 80 1e 00 4c lwz r0,76(r30)
ffc0eab4: 2f 80 00 01 cmpwi cr7,r0,1
ffc0eab8: 41 9e 00 50 beq- cr7,ffc0eb08 <IMFS_evaluate_for_make+0x240>
ffc0eabc: 80 01 00 10 lwz r0,16(r1)
ffc0eac0: 80 81 00 08 lwz r4,8(r1)
}
i += 2;
pathlen -= 2;
node = node->Parent;
}
pathloc->node_access = node;
ffc0eac4: 93 df 00 00 stw r30,0(r31)
ffc0eac8: 4b ff fe 58 b ffc0e920 <IMFS_evaluate_for_make+0x58>
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
ffc0eacc: 7f e3 fb 78 mr r3,r31
ffc0ead0: 38 80 00 01 li r4,1
ffc0ead4: 4b ff f7 35 bl ffc0e208 <IMFS_evaluate_permission>
ffc0ead8: 2f 83 00 00 cmpwi cr7,r3,0
ffc0eadc: 41 9e 01 74 beq- cr7,ffc0ec50 <IMFS_evaluate_for_make+0x388>
ffc0eae0: 80 7f 00 00 lwz r3,0(r31)
ffc0eae4: 4b ff fe d0 b ffc0e9b4 <IMFS_evaluate_for_make+0xec>
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
ffc0eae8: 7f e3 fb 78 mr r3,r31
ffc0eaec: 38 80 00 00 li r4,0
ffc0eaf0: 4b ff fc c5 bl ffc0e7b4 <IMFS_evaluate_link>
if ( result == -1 )
ffc0eaf4: 2f 83 ff ff cmpwi cr7,r3,-1
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
ffc0eaf8: 7c 7e 1b 78 mr r30,r3
if ( result == -1 )
ffc0eafc: 41 be fe 78 beq- cr7,ffc0e974 <IMFS_evaluate_for_make+0xac><== NEVER TAKEN
ffc0eb00: 80 7f 00 00 lwz r3,0(r31)
ffc0eb04: 4b ff ff 88 b ffc0ea8c <IMFS_evaluate_for_make+0x1c4>
*/
if ( ! node )
done = true;
else {
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
ffc0eb08: 80 1e 00 5c lwz r0,92(r30)
ffc0eb0c: 2f 80 00 00 cmpwi cr7,r0,0
ffc0eb10: 41 be ff ac beq- cr7,ffc0eabc <IMFS_evaluate_for_make+0x1f4>
IMFS_skip_separator( path, &pathlen, &i);
ffc0eb14: 7f a3 eb 78 mr r3,r29
ffc0eb18: 38 81 00 08 addi r4,r1,8
ffc0eb1c: 38 a1 00 10 addi r5,r1,16
ffc0eb20: 4b ff f5 d5 bl ffc0e0f4 <IMFS_skip_separator>
if ((path[i] != '.') || (path[i + 1] != '.')) {
ffc0eb24: 81 21 00 10 lwz r9,16(r1)
ffc0eb28: 7c 1d 48 ae lbzx r0,r29,r9
ffc0eb2c: 7c 7d 4a 14 add r3,r29,r9
ffc0eb30: 2f 80 00 2e cmpwi cr7,r0,46
ffc0eb34: 40 9e 01 54 bne- cr7,ffc0ec88 <IMFS_evaluate_for_make+0x3c0>
ffc0eb38: 88 03 00 01 lbz r0,1(r3)
ffc0eb3c: 2f 80 00 2e cmpwi cr7,r0,46
ffc0eb40: 40 9e 01 48 bne- cr7,ffc0ec88 <IMFS_evaluate_for_make+0x3c0><== NEVER TAKEN
return (*pathloc->ops->evalformake_h)( &path[i],
pathloc,
name );
}
i += 2;
pathlen -= 2;
ffc0eb44: 80 81 00 08 lwz r4,8(r1)
*pathloc = node->info.directory.mt_fs->mt_fs_root;
return (*pathloc->ops->evalformake_h)( &path[i],
pathloc,
name );
}
i += 2;
ffc0eb48: 38 09 00 02 addi r0,r9,2
pathlen -= 2;
node = node->Parent;
ffc0eb4c: 83 de 00 08 lwz r30,8(r30)
return (*pathloc->ops->evalformake_h)( &path[i],
pathloc,
name );
}
i += 2;
pathlen -= 2;
ffc0eb50: 38 84 ff fe addi r4,r4,-2
*pathloc = node->info.directory.mt_fs->mt_fs_root;
return (*pathloc->ops->evalformake_h)( &path[i],
pathloc,
name );
}
i += 2;
ffc0eb54: 90 01 00 10 stw r0,16(r1)
pathlen -= 2;
ffc0eb58: 90 81 00 08 stw r4,8(r1)
node = node->Parent;
}
pathloc->node_access = node;
ffc0eb5c: 93 df 00 00 stw r30,0(r31)
ffc0eb60: 4b ff fd c0 b ffc0e920 <IMFS_evaluate_for_make+0x58>
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
ffc0eb64: 80 01 00 10 lwz r0,16(r1)
ffc0eb68: 81 21 00 0c lwz r9,12(r1)
ffc0eb6c: 7d 29 00 50 subf r9,r9,r0
ffc0eb70: 7d 3d 4a 14 add r9,r29,r9
ffc0eb74: 91 3b 00 00 stw r9,0(r27)
/*
* 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++) {
ffc0eb78: 7c 7d 00 ae lbzx r3,r29,r0
ffc0eb7c: 2f 83 00 00 cmpwi cr7,r3,0
ffc0eb80: 40 be 00 20 bne+ cr7,ffc0eba0 <IMFS_evaluate_for_make+0x2d8>
ffc0eb84: 48 00 00 9c b ffc0ec20 <IMFS_evaluate_for_make+0x358>
ffc0eb88: 81 21 00 10 lwz r9,16(r1)
ffc0eb8c: 38 09 00 01 addi r0,r9,1
ffc0eb90: 7c 7d 00 ae lbzx r3,r29,r0
ffc0eb94: 90 01 00 10 stw r0,16(r1)
ffc0eb98: 2f 83 00 00 cmpwi cr7,r3,0
ffc0eb9c: 41 9e 00 84 beq- cr7,ffc0ec20 <IMFS_evaluate_for_make+0x358>
if ( !IMFS_is_separator( path[ i ] ) )
ffc0eba0: 4b ff 79 51 bl ffc064f0 <rtems_filesystem_is_separator>
ffc0eba4: 2f 83 00 00 cmpwi cr7,r3,0
ffc0eba8: 40 9e ff e0 bne+ cr7,ffc0eb88 <IMFS_evaluate_for_make+0x2c0>
rtems_set_errno_and_return_minus_one( ENOENT );
ffc0ebac: 48 00 51 e1 bl ffc13d8c <__errno>
ffc0ebb0: 38 00 00 02 li r0,2
ffc0ebb4: 90 03 00 00 stw r0,0(r3)
ffc0ebb8: 3b c0 ff ff li r30,-1
ffc0ebbc: 4b ff fd b8 b ffc0e974 <IMFS_evaluate_for_make+0xac>
/*
* We must have Write and execute permission on the returned node.
*/
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
rtems_set_errno_and_return_minus_one( EACCES );
ffc0ebc0: 80 01 00 10 lwz r0,16(r1)
ffc0ebc4: 80 81 00 08 lwz r4,8(r1)
ffc0ebc8: 4b ff fd 58 b ffc0e920 <IMFS_evaluate_for_make+0x58>
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
*pathloc = pathloc->mt_entry->mt_point_node;
ffc0ebcc: 81 2b 00 14 lwz r9,20(r11)
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
ffc0ebd0: 7f e4 fb 78 mr r4,r31
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
*pathloc = pathloc->mt_entry->mt_point_node;
ffc0ebd4: 80 0b 00 10 lwz r0,16(r11)
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
ffc0ebd8: 7f 65 db 78 mr r5,r27
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
*pathloc = pathloc->mt_entry->mt_point_node;
ffc0ebdc: 81 0b 00 08 lwz r8,8(r11)
ffc0ebe0: 81 4b 00 0c lwz r10,12(r11)
ffc0ebe4: 91 1f 00 00 stw r8,0(r31)
ffc0ebe8: 91 5f 00 04 stw r10,4(r31)
ffc0ebec: 90 1f 00 08 stw r0,8(r31)
ffc0ebf0: 91 3f 00 0c stw r9,12(r31)
ffc0ebf4: 80 0b 00 18 lwz r0,24(r11)
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
ffc0ebf8: 80 61 00 10 lwz r3,16(r1)
ffc0ebfc: 81 61 00 0c lwz r11,12(r1)
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
*pathloc = pathloc->mt_entry->mt_point_node;
ffc0ec00: 90 1f 00 10 stw r0,16(r31)
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
ffc0ec04: 7c 6b 18 50 subf r3,r11,r3
ffc0ec08: 80 09 00 04 lwz r0,4(r9)
ffc0ec0c: 7c 7d 1a 14 add r3,r29,r3
ffc0ec10: 7c 09 03 a6 mtctr r0
ffc0ec14: 4e 80 04 21 bctrl
ffc0ec18: 7c 7e 1b 78 mr r30,r3
ffc0ec1c: 4b ff fd 58 b ffc0e974 <IMFS_evaluate_for_make+0xac>
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
ffc0ec20: 7f e3 fb 78 mr r3,r31
ffc0ec24: 4b ff f5 59 bl ffc0e17c <IMFS_Set_handlers>
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
ffc0ec28: 81 3f 00 00 lwz r9,0(r31)
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
ffc0ec2c: 7c 7e 1b 78 mr r30,r3
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
ffc0ec30: 80 09 00 4c lwz r0,76(r9)
ffc0ec34: 2f 80 00 01 cmpwi cr7,r0,1
ffc0ec38: 40 9e 00 2c bne- cr7,ffc0ec64 <IMFS_evaluate_for_make+0x39c><== NEVER TAKEN
/*
* We must have Write and execute permission on the returned node.
*/
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
ffc0ec3c: 7f e3 fb 78 mr r3,r31
ffc0ec40: 38 80 00 03 li r4,3
ffc0ec44: 4b ff f5 c5 bl ffc0e208 <IMFS_evaluate_permission>
ffc0ec48: 2f 83 00 00 cmpwi cr7,r3,0
ffc0ec4c: 40 9e fd 28 bne+ cr7,ffc0e974 <IMFS_evaluate_for_make+0xac>
rtems_set_errno_and_return_minus_one( EACCES );
ffc0ec50: 48 00 51 3d bl ffc13d8c <__errno>
ffc0ec54: 38 00 00 0d li r0,13
ffc0ec58: 90 03 00 00 stw r0,0(r3)
ffc0ec5c: 3b c0 ff ff li r30,-1
ffc0ec60: 4b ff fd 14 b ffc0e974 <IMFS_evaluate_for_make+0xac>
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
ffc0ec64: 48 00 51 29 bl ffc13d8c <__errno>
ffc0ec68: 38 00 00 14 li r0,20
ffc0ec6c: 90 03 00 00 stw r0,0(r3)
ffc0ec70: 3b c0 ff ff li r30,-1
ffc0ec74: 4b ff fd 00 b ffc0e974 <IMFS_evaluate_for_make+0xac>
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
}
} else {
if ( !node->Parent )
rtems_set_errno_and_return_minus_one( ENOENT );
ffc0ec78: 48 00 51 15 bl ffc13d8c <__errno>
ffc0ec7c: 3b c0 ff ff li r30,-1
ffc0ec80: 93 43 00 00 stw r26,0(r3)
ffc0ec84: 4b ff fc f0 b ffc0e974 <IMFS_evaluate_for_make+0xac>
done = true;
else {
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
IMFS_skip_separator( path, &pathlen, &i);
if ((path[i] != '.') || (path[i + 1] != '.')) {
*pathloc = node->info.directory.mt_fs->mt_fs_root;
ffc0ec88: 81 3e 00 5c lwz r9,92(r30)
return (*pathloc->ops->evalformake_h)( &path[i],
ffc0ec8c: 7f e4 fb 78 mr r4,r31
ffc0ec90: 7f 65 db 78 mr r5,r27
done = true;
else {
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
IMFS_skip_separator( path, &pathlen, &i);
if ((path[i] != '.') || (path[i + 1] != '.')) {
*pathloc = node->info.directory.mt_fs->mt_fs_root;
ffc0ec94: 81 69 00 28 lwz r11,40(r9)
ffc0ec98: 80 09 00 24 lwz r0,36(r9)
ffc0ec9c: 81 09 00 1c lwz r8,28(r9)
ffc0eca0: 81 49 00 20 lwz r10,32(r9)
ffc0eca4: 90 1f 00 08 stw r0,8(r31)
ffc0eca8: 91 1f 00 00 stw r8,0(r31)
ffc0ecac: 91 5f 00 04 stw r10,4(r31)
ffc0ecb0: 91 7f 00 0c stw r11,12(r31)
return (*pathloc->ops->evalformake_h)( &path[i],
ffc0ecb4: 80 0b 00 04 lwz r0,4(r11)
done = true;
else {
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
IMFS_skip_separator( path, &pathlen, &i);
if ((path[i] != '.') || (path[i + 1] != '.')) {
*pathloc = node->info.directory.mt_fs->mt_fs_root;
ffc0ecb8: 81 29 00 2c lwz r9,44(r9)
return (*pathloc->ops->evalformake_h)( &path[i],
ffc0ecbc: 7c 09 03 a6 mtctr r0
done = true;
else {
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
IMFS_skip_separator( path, &pathlen, &i);
if ((path[i] != '.') || (path[i + 1] != '.')) {
*pathloc = node->info.directory.mt_fs->mt_fs_root;
ffc0ecc0: 91 3f 00 10 stw r9,16(r31)
return (*pathloc->ops->evalformake_h)( &path[i],
ffc0ecc4: 4e 80 04 21 bctrl
ffc0ecc8: 7c 7e 1b 78 mr r30,r3
ffc0eccc: 4b ff fc a8 b ffc0e974 <IMFS_evaluate_for_make+0xac>
ffc0e7b4 <IMFS_evaluate_link>:
*/
int IMFS_evaluate_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
ffc0e7b4: 94 21 ff e8 stwu r1,-24(r1)
ffc0e7b8: 7c 08 02 a6 mflr r0
ffc0e7bc: 93 a1 00 0c stw r29,12(r1)
*/
rtems_filesystem_link_counts ++;
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
rtems_filesystem_link_counts = 0;
rtems_set_errno_and_return_minus_one( ELOOP );
ffc0e7c0: 3f a0 00 00 lis r29,0
*/
int IMFS_evaluate_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
ffc0e7c4: 93 81 00 08 stw r28,8(r1)
ffc0e7c8: 7c 9c 23 78 mr r28,r4
ffc0e7cc: 93 c1 00 10 stw r30,16(r1)
ffc0e7d0: 7c 7e 1b 78 mr r30,r3
ffc0e7d4: 90 01 00 1c stw r0,28(r1)
ffc0e7d8: 93 e1 00 14 stw r31,20(r1)
*/
rtems_filesystem_link_counts ++;
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
rtems_filesystem_link_counts = 0;
rtems_set_errno_and_return_minus_one( ELOOP );
ffc0e7dc: 81 3d 27 7c lwz r9,10108(r29)
ffc0e7e0: 48 00 00 14 b ffc0e7f4 <IMFS_evaluate_link+0x40>
*/
if ( jnode->type == IMFS_HARD_LINK )
result = IMFS_evaluate_hard_link( node, flags );
else if (jnode->type == IMFS_SYM_LINK )
ffc0e7e4: 41 9a 00 90 beq- cr6,ffc0e874 <IMFS_evaluate_link+0xc0>
result = IMFS_evaluate_sym_link( node, flags );
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
ffc0e7e8: 39 6b ff fd addi r11,r11,-3
ffc0e7ec: 2b 8b 00 01 cmplwi cr7,r11,1
ffc0e7f0: 41 9d 00 58 bgt- cr7,ffc0e848 <IMFS_evaluate_link+0x94> <== ALWAYS TAKEN
/*
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
ffc0e7f4: a1 69 00 30 lhz r11,48(r9)
{
IMFS_jnode_t *jnode;
int result = 0;
do {
jnode = node->node_access;
ffc0e7f8: 83 fe 00 00 lwz r31,0(r30)
/*
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
ffc0e7fc: 38 0b 00 01 addi r0,r11,1
ffc0e800: 54 00 04 3e clrlwi r0,r0,16
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
ffc0e804: 2b 80 00 05 cmplwi cr7,r0,5
/*
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
ffc0e808: b0 09 00 30 sth r0,48(r9)
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
ffc0e80c: 41 9d 00 84 bgt- cr7,ffc0e890 <IMFS_evaluate_link+0xdc>
/*
* Follow the Link node.
*/
if ( jnode->type == IMFS_HARD_LINK )
ffc0e810: 81 7f 00 4c lwz r11,76(r31)
ffc0e814: 2f 8b 00 03 cmpwi cr7,r11,3
result = IMFS_evaluate_hard_link( node, flags );
else if (jnode->type == IMFS_SYM_LINK )
ffc0e818: 2f 0b 00 04 cmpwi cr6,r11,4
/*
* Follow the Link node.
*/
if ( jnode->type == IMFS_HARD_LINK )
ffc0e81c: 40 9e ff c8 bne+ cr7,ffc0e7e4 <IMFS_evaluate_link+0x30>
result = IMFS_evaluate_hard_link( node, flags );
ffc0e820: 7f c3 f3 78 mr r3,r30
ffc0e824: 7f 84 e3 78 mr r4,r28
ffc0e828: 4b ff fa 81 bl ffc0e2a8 <IMFS_evaluate_hard_link>
else if (jnode->type == IMFS_SYM_LINK )
result = IMFS_evaluate_sym_link( node, flags );
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
( jnode->type == IMFS_HARD_LINK ) ) );
ffc0e82c: 2f 83 00 00 cmpwi cr7,r3,0
ffc0e830: 40 9e 00 58 bne- cr7,ffc0e888 <IMFS_evaluate_link+0xd4>
ffc0e834: 81 7f 00 4c lwz r11,76(r31)
ffc0e838: 81 3d 27 7c lwz r9,10108(r29)
result = IMFS_evaluate_hard_link( node, flags );
else if (jnode->type == IMFS_SYM_LINK )
result = IMFS_evaluate_sym_link( node, flags );
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
ffc0e83c: 39 6b ff fd addi r11,r11,-3
ffc0e840: 2b 8b 00 01 cmplwi cr7,r11,1
ffc0e844: 40 9d ff b0 ble+ cr7,ffc0e7f4 <IMFS_evaluate_link+0x40> <== ALWAYS TAKEN
ffc0e848: 38 60 00 00 li r3,0
/*
* Clear link counter.
*/
rtems_filesystem_link_counts = 0;
ffc0e84c: 38 00 00 00 li r0,0
return result;
}
ffc0e850: 83 81 00 08 lwz r28,8(r1)
/*
* Clear link counter.
*/
rtems_filesystem_link_counts = 0;
ffc0e854: b0 09 00 30 sth r0,48(r9)
return result;
}
ffc0e858: 80 01 00 1c lwz r0,28(r1)
ffc0e85c: 83 a1 00 0c lwz r29,12(r1)
ffc0e860: 7c 08 03 a6 mtlr r0
ffc0e864: 83 c1 00 10 lwz r30,16(r1)
ffc0e868: 83 e1 00 14 lwz r31,20(r1)
ffc0e86c: 38 21 00 18 addi r1,r1,24
ffc0e870: 4e 80 00 20 blr
if ( jnode->type == IMFS_HARD_LINK )
result = IMFS_evaluate_hard_link( node, flags );
else if (jnode->type == IMFS_SYM_LINK )
result = IMFS_evaluate_sym_link( node, flags );
ffc0e874: 7f c3 f3 78 mr r3,r30
ffc0e878: 7f 84 e3 78 mr r4,r28
ffc0e87c: 4b ff fe 81 bl ffc0e6fc <IMFS_evaluate_sym_link>
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
( jnode->type == IMFS_HARD_LINK ) ) );
ffc0e880: 2f 83 00 00 cmpwi cr7,r3,0
ffc0e884: 41 9e ff b0 beq+ cr7,ffc0e834 <IMFS_evaluate_link+0x80>
ffc0e888: 81 3d 27 7c lwz r9,10108(r29)
ffc0e88c: 4b ff ff c0 b ffc0e84c <IMFS_evaluate_link+0x98>
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
rtems_filesystem_link_counts = 0;
ffc0e890: 38 00 00 00 li r0,0
ffc0e894: b0 09 00 30 sth r0,48(r9)
rtems_set_errno_and_return_minus_one( ELOOP );
ffc0e898: 48 00 54 f5 bl ffc13d8c <__errno>
ffc0e89c: 38 00 00 5c li r0,92
ffc0e8a0: 90 03 00 00 stw r0,0(r3)
ffc0e8a4: 38 60 ff ff li r3,-1
*/
rtems_filesystem_link_counts = 0;
return result;
}
ffc0e8a8: 80 01 00 1c lwz r0,28(r1)
ffc0e8ac: 83 81 00 08 lwz r28,8(r1)
ffc0e8b0: 7c 08 03 a6 mtlr r0
ffc0e8b4: 83 a1 00 0c lwz r29,12(r1)
ffc0e8b8: 83 c1 00 10 lwz r30,16(r1)
ffc0e8bc: 83 e1 00 14 lwz r31,20(r1)
ffc0e8c0: 38 21 00 18 addi r1,r1,24
ffc0e8c4: 4e 80 00 20 blr
ffc0e208 <IMFS_evaluate_permission>:
*/
int IMFS_evaluate_permission(
rtems_filesystem_location_info_t *node,
int flags
)
{
ffc0e208: 94 21 ff e8 stwu r1,-24(r1)
ffc0e20c: 7c 08 02 a6 mflr r0
ffc0e210: 90 01 00 1c stw r0,28(r1)
uid_t st_uid;
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
ffc0e214: 54 80 00 39 rlwinm. r0,r4,0,0,28
*/
int IMFS_evaluate_permission(
rtems_filesystem_location_info_t *node,
int flags
)
{
ffc0e218: 93 c1 00 10 stw r30,16(r1)
ffc0e21c: 7c 9e 23 78 mr r30,r4
ffc0e220: 93 a1 00 0c stw r29,12(r1)
ffc0e224: 93 e1 00 14 stw r31,20(r1)
uid_t st_uid;
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
ffc0e228: 40 82 00 6c bne- ffc0e294 <IMFS_evaluate_permission+0x8c><== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
jnode = node->node_access;
ffc0e22c: 83 e3 00 00 lwz r31,0(r3)
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
ffc0e230: 48 00 13 31 bl ffc0f560 <geteuid>
ffc0e234: 7c 7d 1b 78 mr r29,r3
st_gid = getegid();
ffc0e238: 48 00 13 19 bl ffc0f550 <getegid>
* Check if I am owner or a group member or someone else.
*/
flags_to_test = flags;
if ( st_uid == jnode->st_uid )
ffc0e23c: a0 1f 00 3c lhz r0,60(r31)
ffc0e240: 7f 80 e8 00 cmpw cr7,r0,r29
ffc0e244: 41 9e 00 40 beq- cr7,ffc0e284 <IMFS_evaluate_permission+0x7c>
flags_to_test <<= 6;
else if ( st_gid == jnode->st_gid )
ffc0e248: a0 1f 00 3e lhz r0,62(r31)
ffc0e24c: 7f 80 18 00 cmpw cr7,r0,r3
ffc0e250: 41 9e 00 3c beq- cr7,ffc0e28c <IMFS_evaluate_permission+0x84>
/*
* If all of the flags are set we have permission
* to do this.
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
ffc0e254: 80 7f 00 30 lwz r3,48(r31)
ffc0e258: 7f c3 18 38 and r3,r30,r3
return 1;
ffc0e25c: 7f c3 1a 78 xor r3,r30,r3
ffc0e260: 7c 63 00 34 cntlzw r3,r3
ffc0e264: 54 63 d9 7e rlwinm r3,r3,27,5,31
return 0;
}
ffc0e268: 80 01 00 1c lwz r0,28(r1)
ffc0e26c: 83 a1 00 0c lwz r29,12(r1)
ffc0e270: 7c 08 03 a6 mtlr r0
ffc0e274: 83 c1 00 10 lwz r30,16(r1)
ffc0e278: 83 e1 00 14 lwz r31,20(r1)
ffc0e27c: 38 21 00 18 addi r1,r1,24
ffc0e280: 4e 80 00 20 blr
*/
flags_to_test = flags;
if ( st_uid == jnode->st_uid )
flags_to_test <<= 6;
ffc0e284: 57 de 30 32 rlwinm r30,r30,6,0,25
ffc0e288: 4b ff ff cc b ffc0e254 <IMFS_evaluate_permission+0x4c>
else if ( st_gid == jnode->st_gid )
flags_to_test <<= 3;
ffc0e28c: 57 de 18 38 rlwinm r30,r30,3,0,28
ffc0e290: 4b ff ff c4 b ffc0e254 <IMFS_evaluate_permission+0x4c>
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 );
ffc0e294: 48 00 5a f9 bl ffc13d8c <__errno> <== NOT EXECUTED
ffc0e298: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc0e29c: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc0e2a0: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc0e2a4: 4b ff ff c4 b ffc0e268 <IMFS_evaluate_permission+0x60><== NOT EXECUTED
ffc12f5c <IMFS_fchmod>:
int IMFS_fchmod(
rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
ffc12f5c: 94 21 ff e0 stwu r1,-32(r1)
ffc12f60: 7c 08 02 a6 mflr r0
ffc12f64: 90 01 00 24 stw r0,36(r1)
ffc12f68: 93 e1 00 1c stw r31,28(r1)
IMFS_jnode_t *jnode;
#if defined(RTEMS_POSIX_API)
uid_t st_uid;
#endif
jnode = loc->node_access;
ffc12f6c: 83 e3 00 00 lwz r31,0(r3)
int IMFS_fchmod(
rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
ffc12f70: 93 c1 00 18 stw r30,24(r1)
ffc12f74: 7c 9e 23 78 mr r30,r4
/*
* Verify I am the owner of the node or the super user.
*/
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
ffc12f78: 4b ff c5 e9 bl ffc0f560 <geteuid>
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
ffc12f7c: a0 1f 00 3c lhz r0,60(r31)
ffc12f80: 7f 80 18 00 cmpw cr7,r0,r3
ffc12f84: 41 9e 00 0c beq- cr7,ffc12f90 <IMFS_fchmod+0x34>
ffc12f88: 2f 83 00 00 cmpwi cr7,r3,0
ffc12f8c: 40 9e 00 48 bne- cr7,ffc12fd4 <IMFS_fchmod+0x78> <== ALWAYS TAKEN
/*
* Change only the RWX permissions on the jnode to mode.
*/
jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
ffc12f90: 80 1f 00 30 lwz r0,48(r31)
jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
ffc12f94: 57 de 05 3e clrlwi r30,r30,20
IMFS_update_ctime( jnode );
ffc12f98: 38 61 00 08 addi r3,r1,8
/*
* Change only the RWX permissions on the jnode to mode.
*/
jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
ffc12f9c: 54 00 00 26 rlwinm r0,r0,0,0,19
jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
ffc12fa0: 7f de 03 78 or r30,r30,r0
ffc12fa4: 93 df 00 30 stw r30,48(r31)
IMFS_update_ctime( jnode );
ffc12fa8: 38 80 00 00 li r4,0
ffc12fac: 4b ff 22 b9 bl ffc05264 <gettimeofday>
ffc12fb0: 80 01 00 08 lwz r0,8(r1)
return 0;
ffc12fb4: 38 60 00 00 li r3,0
*/
jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
IMFS_update_ctime( jnode );
ffc12fb8: 90 1f 00 48 stw r0,72(r31)
return 0;
}
ffc12fbc: 80 01 00 24 lwz r0,36(r1)
ffc12fc0: 83 c1 00 18 lwz r30,24(r1)
ffc12fc4: 7c 08 03 a6 mtlr r0
ffc12fc8: 83 e1 00 1c lwz r31,28(r1)
ffc12fcc: 38 21 00 20 addi r1,r1,32
ffc12fd0: 4e 80 00 20 blr
*/
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
rtems_set_errno_and_return_minus_one( EPERM );
ffc12fd4: 48 00 0d b9 bl ffc13d8c <__errno>
ffc12fd8: 38 00 00 01 li r0,1
ffc12fdc: 90 03 00 00 stw r0,0(r3)
ffc12fe0: 38 60 ff ff li r3,-1
ffc12fe4: 4b ff ff d8 b ffc12fbc <IMFS_fchmod+0x60>
ffc059cc <IMFS_fifo_lseek>:
rtems_off64_t IMFS_fifo_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
ffc059cc: 94 21 ff f0 stwu r1,-16(r1)
ffc059d0: 7c 08 02 a6 mflr r0
ffc059d4: 7c 68 1b 78 mr r8,r3
ffc059d8: 90 01 00 14 stw r0,20(r1)
ffc059dc: 93 c1 00 08 stw r30,8(r1)
ffc059e0: 93 e1 00 0c stw r31,12(r1)
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
ffc059e4: 81 23 00 1c lwz r9,28(r3)
ffc059e8: 80 69 00 50 lwz r3,80(r9)
ffc059ec: 48 00 c7 bd bl ffc121a8 <pipe_lseek>
ffc059f0: 7c 7e fe 70 srawi r30,r3,31
IMFS_FIFO_RETURN(err);
ffc059f4: 2f 9e 00 00 cmpwi cr7,r30,0
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
ffc059f8: 7c 7f 1b 78 mr r31,r3
IMFS_FIFO_RETURN(err);
ffc059fc: 41 9c 00 24 blt- cr7,ffc05a20 <IMFS_fifo_lseek+0x54> <== ALWAYS TAKEN
}
ffc05a00: 80 01 00 14 lwz r0,20(r1)
ffc05a04: 7f c3 f3 78 mr r3,r30
ffc05a08: 7f e4 fb 78 mr r4,r31
ffc05a0c: 83 c1 00 08 lwz r30,8(r1)
ffc05a10: 7c 08 03 a6 mtlr r0
ffc05a14: 83 e1 00 0c lwz r31,12(r1)
ffc05a18: 38 21 00 10 addi r1,r1,16
ffc05a1c: 4e 80 00 20 blr
rtems_off64_t offset,
int whence
)
{
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
IMFS_FIFO_RETURN(err);
ffc05a20: 48 01 06 a1 bl ffc160c0 <__errno>
ffc05a24: 7c 1f 00 d0 neg r0,r31
ffc05a28: 90 03 00 00 stw r0,0(r3)
ffc05a2c: 3b c0 ff ff li r30,-1
ffc05a30: 3b e0 ff ff li r31,-1
ffc05a34: 4b ff ff cc b ffc05a00 <IMFS_fifo_lseek+0x34>
ffc05a38 <IMFS_fifo_write>:
ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
ffc05a38: 94 21 ff e0 stwu r1,-32(r1)
ffc05a3c: 7c 08 02 a6 mflr r0
ffc05a40: 7c 66 1b 78 mr r6,r3
ffc05a44: 90 01 00 24 stw r0,36(r1)
ffc05a48: 93 c1 00 18 stw r30,24(r1)
ffc05a4c: 93 e1 00 1c stw r31,28(r1)
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
ffc05a50: 83 e3 00 1c lwz r31,28(r3)
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
ffc05a54: 80 7f 00 50 lwz r3,80(r31)
ffc05a58: 48 00 c4 41 bl ffc11e98 <pipe_write>
if (err > 0) {
ffc05a5c: 7c 7e 1b 79 mr. r30,r3
ffc05a60: 40 81 00 38 ble- ffc05a98 <IMFS_fifo_write+0x60>
IMFS_mtime_ctime_update(jnode);
ffc05a64: 38 61 00 08 addi r3,r1,8
ffc05a68: 38 80 00 00 li r4,0
ffc05a6c: 48 00 16 fd bl ffc07168 <gettimeofday>
ffc05a70: 80 01 00 08 lwz r0,8(r1)
ffc05a74: 90 1f 00 44 stw r0,68(r31)
ffc05a78: 90 1f 00 48 stw r0,72(r31)
}
IMFS_FIFO_RETURN(err);
}
ffc05a7c: 80 01 00 24 lwz r0,36(r1)
ffc05a80: 7f c3 f3 78 mr r3,r30
ffc05a84: 83 e1 00 1c lwz r31,28(r1)
ffc05a88: 7c 08 03 a6 mtlr r0
ffc05a8c: 83 c1 00 18 lwz r30,24(r1)
ffc05a90: 38 21 00 20 addi r1,r1,32
ffc05a94: 4e 80 00 20 blr
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
if (err > 0) {
IMFS_mtime_ctime_update(jnode);
}
IMFS_FIFO_RETURN(err);
ffc05a98: 41 82 ff e4 beq+ ffc05a7c <IMFS_fifo_write+0x44> <== NEVER TAKEN
ffc05a9c: 7f de 00 d0 neg r30,r30
ffc05aa0: 48 01 06 21 bl ffc160c0 <__errno>
ffc05aa4: 93 c3 00 00 stw r30,0(r3)
ffc05aa8: 3b c0 ff ff li r30,-1
ffc05aac: 4b ff ff d0 b ffc05a7c <IMFS_fifo_write+0x44>
ffc0ede4 <IMFS_find_match_in_dir>:
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
ffc0ede4: 94 21 ff e8 stwu r1,-24(r1)
ffc0ede8: 7c 08 02 a6 mflr r0
ffc0edec: 93 e1 00 14 stw r31,20(r1)
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
ffc0edf0: 3f e0 ff c2 lis r31,-62
ffc0edf4: 3b ff 0d 68 addi r31,r31,3432
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
ffc0edf8: 93 c1 00 10 stw r30,16(r1)
ffc0edfc: 7c 9e 23 78 mr r30,r4
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
ffc0ee00: 7f e4 fb 78 mr r4,r31
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
ffc0ee04: 93 81 00 08 stw r28,8(r1)
ffc0ee08: 7c 7c 1b 78 mr r28,r3
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
ffc0ee0c: 7f c3 f3 78 mr r3,r30
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
ffc0ee10: 90 01 00 1c stw r0,28(r1)
ffc0ee14: 93 a1 00 0c stw r29,12(r1)
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
ffc0ee18: 48 00 62 c5 bl ffc150dc <strcmp>
ffc0ee1c: 2f 83 00 00 cmpwi cr7,r3,0
ffc0ee20: 41 9e 00 54 beq- cr7,ffc0ee74 <IMFS_find_match_in_dir+0x90><== NEVER TAKEN
return directory;
if ( !strcmp( name, dotdotname ) )
ffc0ee24: 7f c3 f3 78 mr r3,r30
ffc0ee28: 38 9f 00 04 addi r4,r31,4
ffc0ee2c: 48 00 62 b1 bl ffc150dc <strcmp>
ffc0ee30: 2f 83 00 00 cmpwi cr7,r3,0
ffc0ee34: 41 9e 00 64 beq- cr7,ffc0ee98 <IMFS_find_match_in_dir+0xb4><== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc0ee38: 83 fc 00 50 lwz r31,80(r28)
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
ffc0ee3c: 3b bc 00 54 addi r29,r28,84
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
ffc0ee40: 3b 80 00 00 li r28,0
if ( !strcmp( name, dotdotname ) )
return directory->Parent;
the_chain = &directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
ffc0ee44: 7f 9f e8 00 cmpw cr7,r31,r29
ffc0ee48: 40 be 00 14 bne+ cr7,ffc0ee5c <IMFS_find_match_in_dir+0x78>
ffc0ee4c: 48 00 00 28 b ffc0ee74 <IMFS_find_match_in_dir+0x90>
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
ffc0ee50: 83 ff 00 00 lwz r31,0(r31)
if ( !strcmp( name, dotdotname ) )
return directory->Parent;
the_chain = &directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
ffc0ee54: 7f 9f e8 00 cmpw cr7,r31,r29
ffc0ee58: 41 9e 00 68 beq- cr7,ffc0eec0 <IMFS_find_match_in_dir+0xdc>
!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 ) )
ffc0ee5c: 38 9f 00 0c addi r4,r31,12
ffc0ee60: 7f c3 f3 78 mr r3,r30
ffc0ee64: 48 00 62 79 bl ffc150dc <strcmp>
ffc0ee68: 2f 83 00 00 cmpwi cr7,r3,0
ffc0ee6c: 40 9e ff e4 bne+ cr7,ffc0ee50 <IMFS_find_match_in_dir+0x6c>
ffc0ee70: 7f fc fb 78 mr r28,r31
return the_jnode;
}
return 0;
}
ffc0ee74: 80 01 00 1c lwz r0,28(r1)
ffc0ee78: 7f 83 e3 78 mr r3,r28
ffc0ee7c: 83 a1 00 0c lwz r29,12(r1)
ffc0ee80: 7c 08 03 a6 mtlr r0
ffc0ee84: 83 81 00 08 lwz r28,8(r1)
ffc0ee88: 83 c1 00 10 lwz r30,16(r1)
ffc0ee8c: 83 e1 00 14 lwz r31,20(r1)
ffc0ee90: 38 21 00 18 addi r1,r1,24
ffc0ee94: 4e 80 00 20 blr
ffc0ee98: 80 01 00 1c lwz r0,28(r1) <== NOT EXECUTED
if ( !strcmp( name, dotname ) )
return directory;
if ( !strcmp( name, dotdotname ) )
return directory->Parent;
ffc0ee9c: 83 9c 00 08 lwz r28,8(r28) <== NOT EXECUTED
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
}
ffc0eea0: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc0eea4: 83 a1 00 0c lwz r29,12(r1) <== NOT EXECUTED
ffc0eea8: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc0eeac: 83 c1 00 10 lwz r30,16(r1) <== NOT EXECUTED
ffc0eeb0: 83 81 00 08 lwz r28,8(r1) <== NOT EXECUTED
ffc0eeb4: 83 e1 00 14 lwz r31,20(r1) <== NOT EXECUTED
ffc0eeb8: 38 21 00 18 addi r1,r1,24 <== NOT EXECUTED
ffc0eebc: 4e 80 00 20 blr <== NOT EXECUTED
ffc0eec0: 80 01 00 1c lwz r0,28(r1)
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
ffc0eec4: 3b 80 00 00 li r28,0
}
ffc0eec8: 7f 83 e3 78 mr r3,r28
ffc0eecc: 83 a1 00 0c lwz r29,12(r1)
ffc0eed0: 7c 08 03 a6 mtlr r0
ffc0eed4: 83 81 00 08 lwz r28,8(r1)
ffc0eed8: 83 c1 00 10 lwz r30,16(r1)
ffc0eedc: 83 e1 00 14 lwz r31,20(r1)
ffc0eee0: 38 21 00 18 addi r1,r1,24
ffc0eee4: 4e 80 00 20 blr
ffc0ecd0 <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
)
{
ffc0ecd0: 94 21 ff d0 stwu r1,-48(r1)
ffc0ecd4: 7c 08 02 a6 mflr r0
ffc0ecd8: 90 01 00 34 stw r0,52(r1)
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access;
loc = temp_mt_entry->mt_fs_root;
ffc0ecdc: 80 03 00 2c lwz r0,44(r3)
((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next))
int IMFS_fsunmount(
rtems_filesystem_mount_table_entry_t *temp_mt_entry
)
{
ffc0ece0: 93 c1 00 28 stw r30,40(r1)
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access;
loc = temp_mt_entry->mt_fs_root;
ffc0ece4: 81 43 00 20 lwz r10,32(r3)
/*
* 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;
ffc0ece8: 83 c3 00 1c lwz r30,28(r3)
loc = temp_mt_entry->mt_fs_root;
ffc0ecec: 81 63 00 24 lwz r11,36(r3)
ffc0ecf0: 81 23 00 28 lwz r9,40(r3)
ffc0ecf4: 90 01 00 18 stw r0,24(r1)
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
ffc0ecf8: 38 00 00 00 li r0,0
((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next))
int IMFS_fsunmount(
rtems_filesystem_mount_table_entry_t *temp_mt_entry
)
{
ffc0ecfc: 93 e1 00 2c stw r31,44(r1)
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access;
loc = temp_mt_entry->mt_fs_root;
ffc0ed00: 93 c1 00 08 stw r30,8(r1)
ffc0ed04: 91 41 00 0c stw r10,12(r1)
ffc0ed08: 91 61 00 10 stw r11,16(r1)
ffc0ed0c: 91 21 00 14 stw r9,20(r1)
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
ffc0ed10: 90 03 00 1c stw r0,28(r3)
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
ffc0ed14: 38 61 00 08 addi r3,r1,8
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
do {
next = jnode->Parent;
ffc0ed18: 83 fe 00 08 lwz r31,8(r30)
loc.node_access = (void *)jnode;
ffc0ed1c: 93 c1 00 08 stw r30,8(r1)
IMFS_Set_handlers( &loc );
ffc0ed20: 4b ff f4 5d bl ffc0e17c <IMFS_Set_handlers>
if ( jnode->type != IMFS_DIRECTORY ) {
ffc0ed24: 80 1e 00 4c lwz r0,76(r30)
ffc0ed28: 2f 80 00 01 cmpwi cr7,r0,1
ffc0ed2c: 40 9e 00 60 bne- cr7,ffc0ed8c <IMFS_fsunmount+0xbc> <== NEVER TAKEN
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
ffc0ed30: 81 3e 00 50 lwz r9,80(r30)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
ffc0ed34: 38 1e 00 54 addi r0,r30,84
ffc0ed38: 7f 89 00 00 cmpw cr7,r9,r0
ffc0ed3c: 41 9e 00 50 beq- cr7,ffc0ed8c <IMFS_fsunmount+0xbc>
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
}
if ( jnode != NULL ) {
ffc0ed40: 2f 9e 00 00 cmpwi cr7,r30,0
ffc0ed44: 41 9e 00 68 beq- cr7,ffc0edac <IMFS_fsunmount+0xdc> <== NEVER TAKEN
if ( jnode->type == IMFS_DIRECTORY ) {
ffc0ed48: 80 1e 00 4c lwz r0,76(r30)
ffc0ed4c: 2f 80 00 01 cmpwi cr7,r0,1
ffc0ed50: 40 9e ff c4 bne+ cr7,ffc0ed14 <IMFS_fsunmount+0x44> <== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
ffc0ed54: 80 1e 00 50 lwz r0,80(r30)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
ffc0ed58: 39 3e 00 54 addi r9,r30,84
if ( jnode_has_children( jnode ) )
ffc0ed5c: 7f 80 48 00 cmpw cr7,r0,r9
ffc0ed60: 41 be ff b4 beq- cr7,ffc0ed14 <IMFS_fsunmount+0x44>
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
ffc0ed64: 2f 80 00 00 cmpwi cr7,r0,0
ffc0ed68: 41 9e 00 44 beq- cr7,ffc0edac <IMFS_fsunmount+0xdc> <== NEVER TAKEN
ffc0ed6c: 7c 1e 03 78 mr r30,r0
temp_mt_entry->mt_fs_root.node_access = NULL;
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
ffc0ed70: 38 61 00 08 addi r3,r1,8
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
do {
next = jnode->Parent;
ffc0ed74: 83 fe 00 08 lwz r31,8(r30)
loc.node_access = (void *)jnode;
ffc0ed78: 93 c1 00 08 stw r30,8(r1)
IMFS_Set_handlers( &loc );
ffc0ed7c: 4b ff f4 01 bl ffc0e17c <IMFS_Set_handlers>
if ( jnode->type != IMFS_DIRECTORY ) {
ffc0ed80: 80 1e 00 4c lwz r0,76(r30)
ffc0ed84: 2f 80 00 01 cmpwi cr7,r0,1
ffc0ed88: 41 be ff a8 beq- cr7,ffc0ed30 <IMFS_fsunmount+0x60>
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
result = IMFS_unlink( NULL, &loc );
ffc0ed8c: 38 60 00 00 li r3,0
ffc0ed90: 38 81 00 08 addi r4,r1,8
ffc0ed94: 4b ff 59 99 bl ffc0472c <IMFS_unlink>
if (result != 0)
ffc0ed98: 2f 83 00 00 cmpwi cr7,r3,0
ffc0ed9c: 40 9e 00 2c bne- cr7,ffc0edc8 <IMFS_fsunmount+0xf8> <== NEVER TAKEN
return -1;
jnode = next;
ffc0eda0: 7f fe fb 78 mr r30,r31
}
if ( jnode != NULL ) {
ffc0eda4: 2f 9e 00 00 cmpwi cr7,r30,0
ffc0eda8: 40 9e ff a0 bne+ cr7,ffc0ed48 <IMFS_fsunmount+0x78>
}
}
} while (jnode != NULL);
return 0;
}
ffc0edac: 80 01 00 34 lwz r0,52(r1)
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
return 0;
ffc0edb0: 38 60 00 00 li r3,0
}
ffc0edb4: 83 c1 00 28 lwz r30,40(r1)
ffc0edb8: 7c 08 03 a6 mtlr r0
ffc0edbc: 83 e1 00 2c lwz r31,44(r1)
ffc0edc0: 38 21 00 30 addi r1,r1,48
ffc0edc4: 4e 80 00 20 blr
ffc0edc8: 80 01 00 34 lwz r0,52(r1) <== NOT EXECUTED
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
ffc0edcc: 38 60 ff ff li r3,-1 <== NOT EXECUTED
}
}
} while (jnode != NULL);
return 0;
}
ffc0edd0: 83 c1 00 28 lwz r30,40(r1) <== NOT EXECUTED
ffc0edd4: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc0edd8: 83 e1 00 2c lwz r31,44(r1) <== NOT EXECUTED
ffc0eddc: 38 21 00 30 addi r1,r1,48 <== NOT EXECUTED
ffc0ede0: 4e 80 00 20 blr <== NOT EXECUTED
ffc0eee8 <IMFS_get_token>:
const char *path,
int pathlen,
char *token,
int *token_len
)
{
ffc0eee8: 94 21 ff e0 stwu r1,-32(r1)
ffc0eeec: 7c 08 02 a6 mflr r0
ffc0eef0: 93 41 00 08 stw r26,8(r1)
ffc0eef4: 7c da 33 78 mr r26,r6
ffc0eef8: 93 81 00 10 stw r28,16(r1)
register int i = 0;
ffc0eefc: 3b 80 00 00 li r28,0
const char *path,
int pathlen,
char *token,
int *token_len
)
{
ffc0ef00: 93 a1 00 14 stw r29,20(r1)
ffc0ef04: 7c 9d 23 78 mr r29,r4
ffc0ef08: 93 c1 00 18 stw r30,24(r1)
ffc0ef0c: 7c be 2b 78 mr r30,r5
ffc0ef10: 93 e1 00 1c stw r31,28(r1)
ffc0ef14: 7c 7f 1b 78 mr r31,r3
ffc0ef18: 90 01 00 24 stw r0,36(r1)
ffc0ef1c: 93 61 00 0c stw r27,12(r1)
register char c;
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
ffc0ef20: 8b 63 00 00 lbz r27,0(r3)
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
ffc0ef24: 48 00 00 08 b ffc0ef2c <IMFS_get_token+0x44>
return IMFS_INVALID_TOKEN;
if ( !IMFS_is_valid_name_char(c) )
type = IMFS_INVALID_TOKEN;
c = path [++i];
ffc0ef28: 7f 7f e0 ae lbzx r27,r31,r28
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
ffc0ef2c: 7f 63 db 78 mr r3,r27
ffc0ef30: 4b ff 75 c1 bl ffc064f0 <rtems_filesystem_is_separator>
ffc0ef34: 7f 1c e8 00 cmpw cr6,r28,r29
ffc0ef38: 2f 83 00 00 cmpwi cr7,r3,0
token[i] = c;
if ( i == IMFS_NAME_MAX )
ffc0ef3c: 2c 9c 00 20 cmpwi cr1,r28,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) ) {
ffc0ef40: 40 9e 00 40 bne- cr7,ffc0ef80 <IMFS_get_token+0x98>
ffc0ef44: 40 98 00 3c bge- cr6,ffc0ef80 <IMFS_get_token+0x98> <== NEVER TAKEN
token[i] = c;
ffc0ef48: 7f 7e e1 ae stbx r27,r30,r28
return IMFS_INVALID_TOKEN;
if ( !IMFS_is_valid_name_char(c) )
type = IMFS_INVALID_TOKEN;
c = path [++i];
ffc0ef4c: 3b 9c 00 01 addi r28,r28,1
c = path[i];
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
token[i] = c;
if ( i == IMFS_NAME_MAX )
ffc0ef50: 40 86 ff d8 bne+ cr1,ffc0ef28 <IMFS_get_token+0x40>
return IMFS_INVALID_TOKEN;
ffc0ef54: 38 60 00 04 li r3,4
else if ( strcmp( token, "." ) == 0 )
type = IMFS_CURRENT_DIR;
}
return type;
}
ffc0ef58: 80 01 00 24 lwz r0,36(r1)
ffc0ef5c: 83 41 00 08 lwz r26,8(r1)
ffc0ef60: 7c 08 03 a6 mtlr r0
ffc0ef64: 83 61 00 0c lwz r27,12(r1)
ffc0ef68: 83 81 00 10 lwz r28,16(r1)
ffc0ef6c: 83 a1 00 14 lwz r29,20(r1)
ffc0ef70: 83 c1 00 18 lwz r30,24(r1)
ffc0ef74: 83 e1 00 1c lwz r31,28(r1)
ffc0ef78: 38 21 00 20 addi r1,r1,32
ffc0ef7c: 4e 80 00 20 blr
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
ffc0ef80: 2f 9c 00 00 cmpwi cr7,r28,0
ffc0ef84: 40 9e 00 28 bne- cr7,ffc0efac <IMFS_get_token+0xc4>
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
ffc0ef88: 2f 9b 00 00 cmpwi cr7,r27,0
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
token[i] = c;
ffc0ef8c: 9b 7e 00 00 stb r27,0(r30)
if ( (token[i] != '\0') && pathlen ) {
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
ffc0ef90: 38 60 00 00 li r3,0
*/
if ( i == 0 ) {
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
ffc0ef94: 41 9e 00 10 beq- cr7,ffc0efa4 <IMFS_get_token+0xbc>
ffc0ef98: 2f 9d 00 00 cmpwi cr7,r29,0
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
ffc0ef9c: 7f 83 e3 78 mr r3,r28
*/
if ( i == 0 ) {
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
ffc0efa0: 40 9e 00 8c bne- cr7,ffc0f02c <IMFS_get_token+0x144>
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
ffc0efa4: 93 9a 00 00 stw r28,0(r26)
ffc0efa8: 4b ff ff b0 b ffc0ef58 <IMFS_get_token+0x70>
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
}
} else if (token[ i-1 ] != '\0') {
ffc0efac: 7d 3e e2 14 add r9,r30,r28
ffc0efb0: 88 09 ff ff lbz r0,-1(r9)
ffc0efb4: 2f 80 00 00 cmpwi cr7,r0,0
ffc0efb8: 41 9e 00 0c beq- cr7,ffc0efc4 <IMFS_get_token+0xdc> <== NEVER TAKEN
token[i] = '\0';
ffc0efbc: 38 00 00 00 li r0,0
ffc0efc0: 7c 1e e1 ae stbx r0,r30,r28
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
ffc0efc4: 93 9a 00 00 stw r28,0(r26)
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == IMFS_NAME ) {
if ( strcmp( token, "..") == 0 )
ffc0efc8: 3c 80 ff c2 lis r4,-62
ffc0efcc: 7f c3 f3 78 mr r3,r30
ffc0efd0: 38 84 0d 74 addi r4,r4,3444
ffc0efd4: 48 00 61 09 bl ffc150dc <strcmp>
ffc0efd8: 2f 83 00 00 cmpwi cr7,r3,0
type = IMFS_UP_DIR;
ffc0efdc: 38 60 00 02 li r3,2
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == IMFS_NAME ) {
if ( strcmp( token, "..") == 0 )
ffc0efe0: 41 be ff 78 beq- cr7,ffc0ef58 <IMFS_get_token+0x70>
type = IMFS_UP_DIR;
else if ( strcmp( token, "." ) == 0 )
ffc0efe4: 3c 80 ff c2 lis r4,-62
ffc0efe8: 7f c3 f3 78 mr r3,r30
ffc0efec: 38 84 0d 70 addi r4,r4,3440
ffc0eff0: 48 00 60 ed bl ffc150dc <strcmp>
type = IMFS_CURRENT_DIR;
}
return type;
}
ffc0eff4: 80 01 00 24 lwz r0,36(r1)
*/
if ( type == IMFS_NAME ) {
if ( strcmp( token, "..") == 0 )
type = IMFS_UP_DIR;
else if ( strcmp( token, "." ) == 0 )
ffc0eff8: 30 63 ff ff addic r3,r3,-1
ffc0effc: 7c 63 19 10 subfe r3,r3,r3
type = IMFS_CURRENT_DIR;
}
return type;
}
ffc0f000: 83 41 00 08 lwz r26,8(r1)
ffc0f004: 7c 08 03 a6 mtlr r0
ffc0f008: 83 61 00 0c lwz r27,12(r1)
*/
if ( type == IMFS_NAME ) {
if ( strcmp( token, "..") == 0 )
type = IMFS_UP_DIR;
else if ( strcmp( token, "." ) == 0 )
ffc0f00c: 54 63 00 3c rlwinm r3,r3,0,0,30
type = IMFS_CURRENT_DIR;
}
return type;
}
ffc0f010: 83 81 00 10 lwz r28,16(r1)
*/
if ( type == IMFS_NAME ) {
if ( strcmp( token, "..") == 0 )
type = IMFS_UP_DIR;
else if ( strcmp( token, "." ) == 0 )
ffc0f014: 38 63 00 03 addi r3,r3,3
type = IMFS_CURRENT_DIR;
}
return type;
}
ffc0f018: 83 a1 00 14 lwz r29,20(r1)
ffc0f01c: 83 c1 00 18 lwz r30,24(r1)
ffc0f020: 83 e1 00 1c lwz r31,28(r1)
ffc0f024: 38 21 00 20 addi r1,r1,32
ffc0f028: 4e 80 00 20 blr
if ( i == 0 ) {
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
i++;
ffc0f02c: 3b 80 00 01 li r28,1
type = IMFS_CURRENT_DIR;
ffc0f030: 38 60 00 01 li r3,1
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
ffc0f034: 93 9a 00 00 stw r28,0(r26)
ffc0f038: 4b ff ff 20 b ffc0ef58 <IMFS_get_token+0x70>
ffc0421c <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
)
{
ffc0421c: 94 21 ff e0 stwu r1,-32(r1)
ffc04220: 7c 08 02 a6 mflr r0
IMFS_jnode_t *jnode;
/*
* determine/check value for imfs_memfile_bytes_per_block
*/
IMFS_determine_bytes_per_block(&imfs_memfile_bytes_per_block,
ffc04224: 3d 20 00 00 lis r9,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
)
{
ffc04228: 90 01 00 24 stw r0,36(r1)
IMFS_jnode_t *jnode;
/*
* determine/check value for imfs_memfile_bytes_per_block
*/
IMFS_determine_bytes_per_block(&imfs_memfile_bytes_per_block,
ffc0422c: 80 09 27 38 lwz r0,10040(r9)
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
)
{
ffc04230: 93 41 00 08 stw r26,8(r1)
ffc04234: 7c fa 3b 78 mr r26,r7
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
if (bit_mask == requested_bytes_per_block) {
ffc04238: 2f 80 00 10 cmpwi cr7,r0,16
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
)
{
ffc0423c: 93 81 00 10 stw r28,16(r1)
ffc04240: 7c dc 33 78 mr r28,r6
ffc04244: 93 a1 00 14 stw r29,20(r1)
ffc04248: 7c 9d 23 78 mr r29,r4
ffc0424c: 93 c1 00 18 stw r30,24(r1)
ffc04250: 7c be 2b 78 mr r30,r5
ffc04254: 93 e1 00 1c stw r31,28(r1)
ffc04258: 7c 7f 1b 78 mr r31,r3
ffc0425c: 93 61 00 0c stw r27,12(r1)
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
if (bit_mask == requested_bytes_per_block) {
ffc04260: 41 9e 00 30 beq- cr7,ffc04290 <IMFS_initialize_support+0x74>
is_valid = true;
break;
}
if(bit_mask > requested_bytes_per_block)
ffc04264: 2f 80 00 0f cmpwi cr7,r0,15
ffc04268: 40 9d 00 24 ble- cr7,ffc0428c <IMFS_initialize_support+0x70>
ffc0426c: 39 60 00 05 li r11,5
ffc04270: 7d 69 03 a6 mtctr r11
ffc04274: 39 20 00 20 li r9,32
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
if (bit_mask == requested_bytes_per_block) {
ffc04278: 7f 80 48 00 cmpw cr7,r0,r9
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
ffc0427c: 55 29 08 3c rlwinm r9,r9,1,0,30
if (bit_mask == requested_bytes_per_block) {
ffc04280: 41 9e 00 10 beq- cr7,ffc04290 <IMFS_initialize_support+0x74>
is_valid = true;
break;
}
if(bit_mask > requested_bytes_per_block)
ffc04284: 41 9c 00 08 blt- cr7,ffc0428c <IMFS_initialize_support+0x70><== NEVER TAKEN
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
ffc04288: 42 00 ff f0 bdnz+ ffc04278 <IMFS_initialize_support+0x5c>
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
? requested_bytes_per_block
: default_bytes_per_block);
ffc0428c: 38 00 00 80 li r0,128
break;
}
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
ffc04290: 3d 20 00 00 lis r9,0
ffc04294: 90 09 27 e8 stw r0,10216(r9)
/*
* 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();
ffc04298: 48 00 9e 0d bl ffc0e0a4 <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;
ffc0429c: 3c 80 ff c2 lis r4,-62
/*
* 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();
ffc042a0: 90 7f 00 1c stw r3,28(r31)
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;
ffc042a4: 38 84 0d 18 addi r4,r4,3352
ffc042a8: 38 a0 00 30 li r5,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();
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
ffc042ac: 93 9f 00 24 stw r28,36(r31)
/*
* 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();
ffc042b0: 7c 7b 1b 78 mr r27,r3
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;
ffc042b4: 38 7f 00 38 addi r3,r31,56
*
* NOTE: UNIX root is 755 and owned by root/root (0/0).
*/
temp_mt_entry->mt_fs_root.node_access = IMFS_create_root_node();
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
temp_mt_entry->mt_fs_root.ops = op_table;
ffc042b8: 93 bf 00 28 stw r29,40(r31)
temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
ffc042bc: 48 01 08 0d bl ffc14ac8 <memcpy>
/*
* Create custom file system data.
*/
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
ffc042c0: 38 60 00 01 li r3,1
ffc042c4: 38 80 00 14 li r4,20
ffc042c8: 48 00 08 d1 bl ffc04b98 <calloc>
if ( !fs_info ) {
ffc042cc: 7c 69 1b 79 mr. r9,r3
ffc042d0: 41 82 00 60 beq- ffc04330 <IMFS_initialize_support+0x114>
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
ffc042d4: 3d 60 00 00 lis r11,0
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;
ffc042d8: 91 3f 00 34 stw r9,52(r31)
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
fs_info->ino_count = 1;
ffc042dc: 38 00 00 01 li r0,1
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
ffc042e0: 81 4b 28 ec lwz r10,10476(r11)
fs_info->fifo_handlers = fifo_handlers;
jnode = temp_mt_entry->mt_fs_root.node_access;
jnode->st_ino = fs_info->ino_count;
return 0;
ffc042e4: 38 60 00 00 li r3,0
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
fs_info->ino_count = 1;
ffc042e8: 90 09 00 04 stw r0,4(r9)
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
ffc042ec: 39 0a 00 01 addi r8,r10,1
ffc042f0: 91 49 00 00 stw r10,0(r9)
fs_info->ino_count = 1;
fs_info->memfile_handlers = memfile_handlers;
ffc042f4: 93 c9 00 08 stw r30,8(r9)
fs_info->directory_handlers = directory_handlers;
ffc042f8: 93 89 00 0c stw r28,12(r9)
fs_info->fifo_handlers = fifo_handlers;
ffc042fc: 93 49 00 10 stw r26,16(r9)
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
ffc04300: 91 0b 28 ec stw r8,10476(r11)
fs_info->memfile_handlers = memfile_handlers;
fs_info->directory_handlers = directory_handlers;
fs_info->fifo_handlers = fifo_handlers;
jnode = temp_mt_entry->mt_fs_root.node_access;
jnode->st_ino = fs_info->ino_count;
ffc04304: 90 1b 00 38 stw r0,56(r27)
return 0;
}
ffc04308: 80 01 00 24 lwz r0,36(r1)
ffc0430c: 83 41 00 08 lwz r26,8(r1)
ffc04310: 7c 08 03 a6 mtlr r0
ffc04314: 83 61 00 0c lwz r27,12(r1)
ffc04318: 83 81 00 10 lwz r28,16(r1)
ffc0431c: 83 a1 00 14 lwz r29,20(r1)
ffc04320: 83 c1 00 18 lwz r30,24(r1)
ffc04324: 83 e1 00 1c lwz r31,28(r1)
ffc04328: 38 21 00 20 addi r1,r1,32
ffc0432c: 4e 80 00 20 blr
/*
* Create custom file system data.
*/
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
if ( !fs_info ) {
free(temp_mt_entry->mt_fs_root.node_access);
ffc04330: 7f 63 db 78 mr r3,r27
ffc04334: 48 00 0e 69 bl ffc0519c <free>
rtems_set_errno_and_return_minus_one(ENOMEM);
ffc04338: 48 00 fa 55 bl ffc13d8c <__errno>
ffc0433c: 38 00 00 0c li r0,12
ffc04340: 90 03 00 00 stw r0,0(r3)
ffc04344: 38 60 ff ff li r3,-1
ffc04348: 4b ff ff c0 b ffc04308 <IMFS_initialize_support+0xec>
ffc1216c <IMFS_memfile_extend>:
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
ffc1216c: 94 21 ff c8 stwu r1,-56(r1)
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
ffc12170: 3d 20 00 00 lis r9,0
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
ffc12174: 7c 08 02 a6 mflr r0
ffc12178: 93 a1 00 2c stw r29,44(r1)
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
ffc1217c: 83 a9 27 e8 lwz r29,10216(r9)
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
ffc12180: 90 01 00 3c stw r0,60(r1)
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
ffc12184: 57 a9 f0 be rlwinm r9,r29,30,2,31
ffc12188: 39 69 00 01 addi r11,r9,1
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
ffc1218c: 93 41 00 20 stw r26,32(r1)
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
ffc12190: 7d 6b 49 d6 mullw r11,r11,r9
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
ffc12194: 93 81 00 28 stw r28,40(r1)
ffc12198: 7c da 33 78 mr r26,r6
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
ffc1219c: 38 0b 00 01 addi r0,r11,1
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
ffc121a0: 93 e1 00 34 stw r31,52(r1)
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
ffc121a4: 39 60 00 00 li r11,0
ffc121a8: 7f 8b 28 00 cmpw cr7,r11,r5
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
ffc121ac: 93 01 00 18 stw r24,24(r1)
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
ffc121b0: 7d 20 49 d6 mullw r9,r0,r9
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
ffc121b4: 93 21 00 1c stw r25,28(r1)
ffc121b8: 7c bc 2b 78 mr r28,r5
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
ffc121bc: 39 29 ff ff addi r9,r9,-1
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
ffc121c0: 93 61 00 24 stw r27,36(r1)
ffc121c4: 7c 7f 1b 78 mr r31,r3
ffc121c8: 93 c1 00 30 stw r30,48(r1)
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
ffc121cc: 7d 29 e9 d6 mullw r9,r9,r29
ffc121d0: 40 9d 01 78 ble- cr7,ffc12348 <IMFS_memfile_extend+0x1dc>
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
ffc121d4: 83 7f 00 50 lwz r27,80(r31)
ffc121d8: 83 3f 00 54 lwz r25,84(r31)
ffc121dc: 7f 9c d8 00 cmpw cr7,r28,r27
ffc121e0: 40 9d 00 c4 ble- cr7,ffc122a4 <IMFS_memfile_extend+0x138><== ALWAYS TAKEN
return 0;
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
ffc121e4: 7f b8 fe 70 srawi r24,r29,31
ffc121e8: 7f 05 c3 78 mr r5,r24
ffc121ec: 7f a6 eb 78 mr r6,r29
ffc121f0: 7f 83 e3 78 mr r3,r28
ffc121f4: 7f 44 d3 78 mr r4,r26
ffc121f8: 48 00 b2 c9 bl ffc1d4c0 <__divdi3>
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
ffc121fc: 7f 63 db 78 mr r3,r27
return 0;
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
ffc12200: 7c 9e 23 78 mr r30,r4
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
ffc12204: 7f 05 c3 78 mr r5,r24
ffc12208: 7f 24 cb 78 mr r4,r25
ffc1220c: 7f a6 eb 78 mr r6,r29
ffc12210: 48 00 b2 b1 bl ffc1d4c0 <__divdi3>
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
ffc12214: 7f 9e 20 40 cmplw cr7,r30,r4
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
ffc12218: 7c 9b 23 78 mr r27,r4
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
ffc1221c: 41 9c 00 c8 blt- cr7,ffc122e4 <IMFS_memfile_extend+0x178><== NEVER TAKEN
ffc12220: 7c 9d 23 78 mr r29,r4
ffc12224: 48 00 00 10 b ffc12234 <IMFS_memfile_extend+0xc8>
ffc12228: 3b bd 00 01 addi r29,r29,1
ffc1222c: 7f 9e e8 40 cmplw cr7,r30,r29
ffc12230: 41 9c 00 b4 blt- cr7,ffc122e4 <IMFS_memfile_extend+0x178>
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
ffc12234: 7f a4 eb 78 mr r4,r29
ffc12238: 7f e3 fb 78 mr r3,r31
ffc1223c: 4b ff fc 2d bl ffc11e68 <IMFS_memfile_addblock>
ffc12240: 2f 83 00 00 cmpwi cr7,r3,0
ffc12244: 41 9e ff e4 beq+ cr7,ffc12228 <IMFS_memfile_extend+0xbc>
ffc12248: 48 00 00 14 b ffc1225c <IMFS_memfile_extend+0xf0>
for ( ; block>=old_blocks ; block-- ) {
IMFS_memfile_remove_block( the_jnode, block );
ffc1224c: 7f a4 eb 78 mr r4,r29
ffc12250: 7f e3 fb 78 mr r3,r31
/*
* 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-- ) {
ffc12254: 3b bd ff ff addi r29,r29,-1
IMFS_memfile_remove_block( the_jnode, block );
ffc12258: 4b ff fe d9 bl ffc12130 <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-- ) {
ffc1225c: 7f 9b e8 40 cmplw cr7,r27,r29
ffc12260: 40 9d ff ec ble+ cr7,ffc1224c <IMFS_memfile_extend+0xe0>
IMFS_memfile_remove_block( the_jnode, block );
}
rtems_set_errno_and_return_minus_one( ENOSPC );
ffc12264: 48 00 1b 29 bl ffc13d8c <__errno>
ffc12268: 38 00 00 1c li r0,28
ffc1226c: 90 03 00 00 stw r0,0(r3)
ffc12270: 38 60 ff ff li r3,-1
the_jnode->info.file.size = new_length;
IMFS_update_ctime(the_jnode);
IMFS_update_mtime(the_jnode);
return 0;
}
ffc12274: 80 01 00 3c lwz r0,60(r1)
ffc12278: 83 01 00 18 lwz r24,24(r1)
ffc1227c: 7c 08 03 a6 mtlr r0
ffc12280: 83 21 00 1c lwz r25,28(r1)
ffc12284: 83 41 00 20 lwz r26,32(r1)
ffc12288: 83 61 00 24 lwz r27,36(r1)
ffc1228c: 83 81 00 28 lwz r28,40(r1)
ffc12290: 83 a1 00 2c lwz r29,44(r1)
ffc12294: 83 c1 00 30 lwz r30,48(r1)
ffc12298: 83 e1 00 34 lwz r31,52(r1)
ffc1229c: 38 21 00 38 addi r1,r1,56
ffc122a0: 4e 80 00 20 blr
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
ffc122a4: 40 9e 00 0c bne- cr7,ffc122b0 <IMFS_memfile_extend+0x144>
ffc122a8: 7f 9a c8 40 cmplw cr7,r26,r25
ffc122ac: 41 9d ff 38 bgt+ cr7,ffc121e4 <IMFS_memfile_extend+0x78>
the_jnode->info.file.size = new_length;
IMFS_update_ctime(the_jnode);
IMFS_update_mtime(the_jnode);
return 0;
}
ffc122b0: 80 01 00 3c lwz r0,60(r1)
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
return 0;
ffc122b4: 38 60 00 00 li r3,0
the_jnode->info.file.size = new_length;
IMFS_update_ctime(the_jnode);
IMFS_update_mtime(the_jnode);
return 0;
}
ffc122b8: 83 01 00 18 lwz r24,24(r1)
ffc122bc: 7c 08 03 a6 mtlr r0
ffc122c0: 83 21 00 1c lwz r25,28(r1)
ffc122c4: 83 41 00 20 lwz r26,32(r1)
ffc122c8: 83 61 00 24 lwz r27,36(r1)
ffc122cc: 83 81 00 28 lwz r28,40(r1)
ffc122d0: 83 a1 00 2c lwz r29,44(r1)
ffc122d4: 83 c1 00 30 lwz r30,48(r1)
ffc122d8: 83 e1 00 34 lwz r31,52(r1)
ffc122dc: 38 21 00 38 addi r1,r1,56
ffc122e0: 4e 80 00 20 blr
}
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
ffc122e4: 93 9f 00 50 stw r28,80(r31)
IMFS_update_ctime(the_jnode);
ffc122e8: 38 80 00 00 li r4,0
ffc122ec: 38 61 00 08 addi r3,r1,8
}
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
ffc122f0: 93 5f 00 54 stw r26,84(r31)
IMFS_update_ctime(the_jnode);
ffc122f4: 4b ff 2f 71 bl ffc05264 <gettimeofday>
ffc122f8: 80 01 00 08 lwz r0,8(r1)
IMFS_update_mtime(the_jnode);
ffc122fc: 38 61 00 08 addi r3,r1,8
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
IMFS_update_ctime(the_jnode);
ffc12300: 90 1f 00 48 stw r0,72(r31)
IMFS_update_mtime(the_jnode);
ffc12304: 38 80 00 00 li r4,0
ffc12308: 4b ff 2f 5d bl ffc05264 <gettimeofday>
ffc1230c: 80 01 00 08 lwz r0,8(r1)
return 0;
ffc12310: 38 60 00 00 li r3,0
}
ffc12314: 83 01 00 18 lwz r24,24(r1)
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
IMFS_update_ctime(the_jnode);
IMFS_update_mtime(the_jnode);
ffc12318: 90 1f 00 44 stw r0,68(r31)
return 0;
}
ffc1231c: 80 01 00 3c lwz r0,60(r1)
ffc12320: 83 21 00 1c lwz r25,28(r1)
ffc12324: 7c 08 03 a6 mtlr r0
ffc12328: 83 41 00 20 lwz r26,32(r1)
ffc1232c: 83 61 00 24 lwz r27,36(r1)
ffc12330: 83 81 00 28 lwz r28,40(r1)
ffc12334: 83 a1 00 2c lwz r29,44(r1)
ffc12338: 83 c1 00 30 lwz r30,48(r1)
ffc1233c: 83 e1 00 34 lwz r31,52(r1)
ffc12340: 38 21 00 38 addi r1,r1,56
ffc12344: 4e 80 00 20 blr
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
ffc12348: 40 9e 00 0c bne- cr7,ffc12354 <IMFS_memfile_extend+0x1e8><== NEVER TAKEN
ffc1234c: 7f 89 30 40 cmplw cr7,r9,r6
ffc12350: 41 9d fe 84 bgt+ cr7,ffc121d4 <IMFS_memfile_extend+0x68>
rtems_set_errno_and_return_minus_one( EINVAL );
ffc12354: 48 00 1a 39 bl ffc13d8c <__errno>
ffc12358: 38 00 00 16 li r0,22
ffc1235c: 90 03 00 00 stw r0,0(r3)
ffc12360: 38 60 ff ff li r3,-1
ffc12364: 4b ff ff 10 b ffc12274 <IMFS_memfile_extend+0x108>
ffc118a8 <IMFS_memfile_get_block_pointer>:
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
ffc118a8: 94 21 ff d8 stwu r1,-40(r1)
ffc118ac: 7c 08 02 a6 mflr r0
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
ffc118b0: 3d 20 00 00 lis r9,0
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
ffc118b4: 90 01 00 2c stw r0,44(r1)
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
ffc118b8: 80 09 27 e8 lwz r0,10216(r9)
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
ffc118bc: 93 e1 00 24 stw r31,36(r1)
ffc118c0: 7c 7f 1b 78 mr r31,r3
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
ffc118c4: 54 09 f0 be rlwinm r9,r0,30,2,31
ffc118c8: 38 09 ff ff addi r0,r9,-1
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
ffc118cc: 93 61 00 14 stw r27,20(r1)
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
ffc118d0: 7f 84 00 40 cmplw cr7,r4,r0
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
ffc118d4: 93 81 00 18 stw r28,24(r1)
ffc118d8: 93 a1 00 1c stw r29,28(r1)
ffc118dc: 93 c1 00 20 stw r30,32(r1)
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
ffc118e0: 41 9d 00 4c bgt- cr7,ffc1192c <IMFS_memfile_get_block_pointer+0x84>
p = info->indirect;
if ( malloc_it ) {
ffc118e4: 2f 85 00 00 cmpwi cr7,r5,0
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
p = info->indirect;
ffc118e8: 80 63 00 58 lwz r3,88(r3)
if ( malloc_it ) {
ffc118ec: 40 9e 01 5c bne- cr7,ffc11a48 <IMFS_memfile_get_block_pointer+0x1a0>
info->indirect = p;
}
return &info->indirect[ my_block ];
}
if ( !p )
ffc118f0: 2f 83 00 00 cmpwi cr7,r3,0
return 0;
ffc118f4: 3b c0 00 00 li r30,0
info->indirect = p;
}
return &info->indirect[ my_block ];
}
if ( !p )
ffc118f8: 41 9e 00 0c beq- cr7,ffc11904 <IMFS_memfile_get_block_pointer+0x5c><== NEVER TAKEN
return 0;
return &info->indirect[ my_block ];
ffc118fc: 54 84 10 3a rlwinm r4,r4,2,0,29
ffc11900: 7f c3 22 14 add r30,r3,r4
/*
* This means the requested block number is out of range.
*/
return 0;
}
ffc11904: 80 01 00 2c lwz r0,44(r1)
ffc11908: 7f c3 f3 78 mr r3,r30
ffc1190c: 83 61 00 14 lwz r27,20(r1)
ffc11910: 7c 08 03 a6 mtlr r0
ffc11914: 83 81 00 18 lwz r28,24(r1)
ffc11918: 83 a1 00 1c lwz r29,28(r1)
ffc1191c: 83 c1 00 20 lwz r30,32(r1)
ffc11920: 83 e1 00 24 lwz r31,36(r1)
ffc11924: 38 21 00 28 addi r1,r1,40
ffc11928: 4e 80 00 20 blr
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
ffc1192c: 3b 69 00 01 addi r27,r9,1
ffc11930: 7f 7b 49 d6 mullw r27,r27,r9
ffc11934: 38 1b ff ff addi r0,r27,-1
ffc11938: 7f 84 00 40 cmplw cr7,r4,r0
ffc1193c: 40 9d 00 a4 ble- cr7,ffc119e0 <IMFS_memfile_get_block_pointer+0x138>
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
ffc11940: 39 7b 00 01 addi r11,r27,1
ffc11944: 7d 6b 49 d6 mullw r11,r11,r9
}
/*
* This means the requested block number is out of range.
*/
return 0;
ffc11948: 3b c0 00 00 li r30,0
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
ffc1194c: 38 0b ff ff addi r0,r11,-1
ffc11950: 7f 84 00 40 cmplw cr7,r4,r0
ffc11954: 41 bd ff b0 bgt- cr7,ffc11904 <IMFS_memfile_get_block_pointer+0x5c><== NEVER TAKEN
my_block -= FIRST_TRIPLY_INDIRECT;
ffc11958: 7c 9b 20 50 subf r4,r27,r4
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
p = info->triply_indirect;
ffc1195c: 81 43 00 60 lwz r10,96(r3)
* 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;
ffc11960: 7d 64 4b 96 divwu r11,r4,r9
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
ffc11964: 7f ab 4b 96 divwu r29,r11,r9
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
p = info->triply_indirect;
if ( malloc_it ) {
ffc11968: 2f 85 00 00 cmpwi cr7,r5,0
* 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;
ffc1196c: 7f 6b 49 d6 mullw r27,r11,r9
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
ffc11970: 7d 3d 49 d6 mullw r9,r29,r9
* 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;
ffc11974: 7f 7b 20 50 subf r27,r27,r4
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
ffc11978: 7f 89 58 50 subf r28,r9,r11
p = info->triply_indirect;
if ( malloc_it ) {
ffc1197c: 41 9e 01 40 beq- cr7,ffc11abc <IMFS_memfile_get_block_pointer+0x214>
if ( !p ) {
ffc11980: 2f 8a 00 00 cmpwi cr7,r10,0
ffc11984: 41 9e 01 f0 beq- cr7,ffc11b74 <IMFS_memfile_get_block_pointer+0x2cc>
if ( !p )
return 0;
info->triply_indirect = p;
}
p1 = (block_p *) p[ triply ];
ffc11988: 57 bd 10 3a rlwinm r29,r29,2,0,29
ffc1198c: 7d 6a e8 2e lwzx r11,r10,r29
ffc11990: 7f aa ea 14 add r29,r10,r29
if ( !p1 ) {
ffc11994: 2f 8b 00 00 cmpwi cr7,r11,0
ffc11998: 41 9e 01 c4 beq- cr7,ffc11b5c <IMFS_memfile_get_block_pointer+0x2b4>
if ( !p1 )
return 0;
p[ triply ] = (block_p) p1;
}
p2 = (block_p *)p1[ doubly ];
ffc1199c: 57 9c 10 3a rlwinm r28,r28,2,0,29
ffc119a0: 7c 6b e0 2e lwzx r3,r11,r28
ffc119a4: 7f 8b e2 14 add r28,r11,r28
if ( !p2 ) {
ffc119a8: 2f 83 00 00 cmpwi cr7,r3,0
ffc119ac: 41 9e 01 80 beq- cr7,ffc11b2c <IMFS_memfile_get_block_pointer+0x284>
/*
* This means the requested block number is out of range.
*/
return 0;
}
ffc119b0: 80 01 00 2c lwz r0,44(r1)
p2 = memfile_alloc_block();
if ( !p2 )
return 0;
p1[ doubly ] = (block_p) p2;
}
return (block_p *)&p2[ singly ];
ffc119b4: 57 7e 10 3a rlwinm r30,r27,2,0,29
ffc119b8: 7f c3 f2 14 add r30,r3,r30
/*
* This means the requested block number is out of range.
*/
return 0;
}
ffc119bc: 83 61 00 14 lwz r27,20(r1)
ffc119c0: 7c 08 03 a6 mtlr r0
ffc119c4: 7f c3 f3 78 mr r3,r30
ffc119c8: 83 81 00 18 lwz r28,24(r1)
ffc119cc: 83 a1 00 1c lwz r29,28(r1)
ffc119d0: 83 c1 00 20 lwz r30,32(r1)
ffc119d4: 83 e1 00 24 lwz r31,36(r1)
ffc119d8: 38 21 00 28 addi r1,r1,40
ffc119dc: 4e 80 00 20 blr
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
my_block -= FIRST_DOUBLY_INDIRECT;
ffc119e0: 7c 89 20 50 subf r4,r9,r4
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
p = info->doubly_indirect;
ffc119e4: 81 63 00 5c lwz r11,92(r3)
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
my_block -= FIRST_DOUBLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
ffc119e8: 7f a4 4b 96 divwu r29,r4,r9
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
p = info->doubly_indirect;
if ( malloc_it ) {
ffc119ec: 2f 85 00 00 cmpwi cr7,r5,0
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
my_block -= FIRST_DOUBLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
ffc119f0: 7d 3d 49 d6 mullw r9,r29,r9
ffc119f4: 7f 89 20 50 subf r28,r9,r4
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
p = info->doubly_indirect;
if ( malloc_it ) {
ffc119f8: 41 9e 00 78 beq- cr7,ffc11a70 <IMFS_memfile_get_block_pointer+0x1c8>
if ( !p ) {
ffc119fc: 2f 8b 00 00 cmpwi cr7,r11,0
ffc11a00: 41 9e 01 44 beq- cr7,ffc11b44 <IMFS_memfile_get_block_pointer+0x29c>
if ( !p )
return 0;
info->doubly_indirect = p;
}
p1 = (block_p *)p[ doubly ];
ffc11a04: 57 bd 10 3a rlwinm r29,r29,2,0,29
ffc11a08: 7c 6b e8 2e lwzx r3,r11,r29
ffc11a0c: 7f ab ea 14 add r29,r11,r29
if ( !p1 ) {
ffc11a10: 2f 83 00 00 cmpwi cr7,r3,0
ffc11a14: 41 9e 01 00 beq- cr7,ffc11b14 <IMFS_memfile_get_block_pointer+0x26c>
/*
* This means the requested block number is out of range.
*/
return 0;
}
ffc11a18: 80 01 00 2c lwz r0,44(r1)
if ( !p1 )
return 0;
p[ doubly ] = (block_p) p1;
}
return (block_p *)&p1[ singly ];
ffc11a1c: 57 9e 10 3a rlwinm r30,r28,2,0,29
ffc11a20: 7f c3 f2 14 add r30,r3,r30
/*
* This means the requested block number is out of range.
*/
return 0;
}
ffc11a24: 83 61 00 14 lwz r27,20(r1)
ffc11a28: 7c 08 03 a6 mtlr r0
ffc11a2c: 7f c3 f3 78 mr r3,r30
ffc11a30: 83 81 00 18 lwz r28,24(r1)
ffc11a34: 83 a1 00 1c lwz r29,28(r1)
ffc11a38: 83 c1 00 20 lwz r30,32(r1)
ffc11a3c: 83 e1 00 24 lwz r31,36(r1)
ffc11a40: 38 21 00 28 addi r1,r1,40
ffc11a44: 4e 80 00 20 blr
if ( my_block <= LAST_INDIRECT ) {
p = info->indirect;
if ( malloc_it ) {
if ( !p ) {
ffc11a48: 2f 83 00 00 cmpwi cr7,r3,0
ffc11a4c: 40 9e fe b0 bne+ cr7,ffc118fc <IMFS_memfile_get_block_pointer+0x54>
p = memfile_alloc_block();
ffc11a50: 90 81 00 08 stw r4,8(r1)
ffc11a54: 4b ff fe 11 bl ffc11864 <memfile_alloc_block>
if ( !p )
ffc11a58: 2c 03 00 00 cmpwi r3,0
return 0;
ffc11a5c: 3b c0 00 00 li r30,0
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
if ( !p )
ffc11a60: 80 81 00 08 lwz r4,8(r1)
ffc11a64: 41 a2 fe a0 beq- ffc11904 <IMFS_memfile_get_block_pointer+0x5c><== NEVER TAKEN
return 0;
info->indirect = p;
ffc11a68: 90 7f 00 58 stw r3,88(r31)
ffc11a6c: 4b ff fe 90 b ffc118fc <IMFS_memfile_get_block_pointer+0x54>
}
return (block_p *)&p1[ singly ];
}
if ( !p )
ffc11a70: 2f 8b 00 00 cmpwi cr7,r11,0
return 0;
ffc11a74: 3b c0 00 00 li r30,0
}
return (block_p *)&p1[ singly ];
}
if ( !p )
ffc11a78: 41 be fe 8c beq- cr7,ffc11904 <IMFS_memfile_get_block_pointer+0x5c><== NEVER TAKEN
return 0;
p = (block_p *)p[ doubly ];
ffc11a7c: 57 bd 10 3a rlwinm r29,r29,2,0,29
ffc11a80: 7c 0b e8 2e lwzx r0,r11,r29
if ( !p )
ffc11a84: 2f 80 00 00 cmpwi cr7,r0,0
ffc11a88: 41 be fe 7c beq- cr7,ffc11904 <IMFS_memfile_get_block_pointer+0x5c><== NEVER TAKEN
return 0;
return (block_p *)&p[ singly ];
ffc11a8c: 57 9e 10 3a rlwinm r30,r28,2,0,29
/*
* This means the requested block number is out of range.
*/
return 0;
}
ffc11a90: 83 61 00 14 lwz r27,20(r1)
p = (block_p *)p[ doubly ];
if ( !p )
return 0;
return (block_p *)&p[ singly ];
ffc11a94: 7f c0 f2 14 add r30,r0,r30
/*
* This means the requested block number is out of range.
*/
return 0;
}
ffc11a98: 80 01 00 2c lwz r0,44(r1)
ffc11a9c: 7f c3 f3 78 mr r3,r30
ffc11aa0: 83 81 00 18 lwz r28,24(r1)
ffc11aa4: 7c 08 03 a6 mtlr r0
ffc11aa8: 83 a1 00 1c lwz r29,28(r1)
ffc11aac: 83 c1 00 20 lwz r30,32(r1)
ffc11ab0: 83 e1 00 24 lwz r31,36(r1)
ffc11ab4: 38 21 00 28 addi r1,r1,40
ffc11ab8: 4e 80 00 20 blr
p1[ doubly ] = (block_p) p2;
}
return (block_p *)&p2[ singly ];
}
if ( !p )
ffc11abc: 2f 8a 00 00 cmpwi cr7,r10,0
ffc11ac0: 41 be fe 44 beq- cr7,ffc11904 <IMFS_memfile_get_block_pointer+0x5c><== NEVER TAKEN
return 0;
p1 = (block_p *) p[ triply ];
ffc11ac4: 57 bd 10 3a rlwinm r29,r29,2,0,29
ffc11ac8: 7d 6a e8 2e lwzx r11,r10,r29
if ( !p1 )
ffc11acc: 2f 8b 00 00 cmpwi cr7,r11,0
ffc11ad0: 41 be fe 34 beq- cr7,ffc11904 <IMFS_memfile_get_block_pointer+0x5c><== NEVER TAKEN
return 0;
p2 = (block_p *)p1[ doubly ];
ffc11ad4: 57 9c 10 3a rlwinm r28,r28,2,0,29
ffc11ad8: 7c 0b e0 2e lwzx r0,r11,r28
if ( !p2 )
ffc11adc: 2f 80 00 00 cmpwi cr7,r0,0
ffc11ae0: 41 be fe 24 beq- cr7,ffc11904 <IMFS_memfile_get_block_pointer+0x5c><== NEVER TAKEN
return 0;
return (block_p *)&p2[ singly ];
ffc11ae4: 57 7e 10 3a rlwinm r30,r27,2,0,29
/*
* This means the requested block number is out of range.
*/
return 0;
}
ffc11ae8: 83 81 00 18 lwz r28,24(r1)
p2 = (block_p *)p1[ doubly ];
if ( !p2 )
return 0;
return (block_p *)&p2[ singly ];
ffc11aec: 7f c0 f2 14 add r30,r0,r30
/*
* This means the requested block number is out of range.
*/
return 0;
}
ffc11af0: 80 01 00 2c lwz r0,44(r1)
ffc11af4: 7f c3 f3 78 mr r3,r30
ffc11af8: 83 61 00 14 lwz r27,20(r1)
ffc11afc: 7c 08 03 a6 mtlr r0
ffc11b00: 83 a1 00 1c lwz r29,28(r1)
ffc11b04: 83 c1 00 20 lwz r30,32(r1)
ffc11b08: 83 e1 00 24 lwz r31,36(r1)
ffc11b0c: 38 21 00 28 addi r1,r1,40
ffc11b10: 4e 80 00 20 blr
info->doubly_indirect = p;
}
p1 = (block_p *)p[ doubly ];
if ( !p1 ) {
p1 = memfile_alloc_block();
ffc11b14: 4b ff fd 51 bl ffc11864 <memfile_alloc_block>
if ( !p1 )
return 0;
ffc11b18: 3b c0 00 00 li r30,0
}
p1 = (block_p *)p[ doubly ];
if ( !p1 ) {
p1 = memfile_alloc_block();
if ( !p1 )
ffc11b1c: 2c 03 00 00 cmpwi r3,0
ffc11b20: 41 a2 fd e4 beq- ffc11904 <IMFS_memfile_get_block_pointer+0x5c><== NEVER TAKEN
return 0;
p[ doubly ] = (block_p) p1;
ffc11b24: 90 7d 00 00 stw r3,0(r29)
ffc11b28: 4b ff fe f0 b ffc11a18 <IMFS_memfile_get_block_pointer+0x170>
p[ triply ] = (block_p) p1;
}
p2 = (block_p *)p1[ doubly ];
if ( !p2 ) {
p2 = memfile_alloc_block();
ffc11b2c: 4b ff fd 39 bl ffc11864 <memfile_alloc_block>
if ( !p2 )
return 0;
ffc11b30: 3b c0 00 00 li r30,0
}
p2 = (block_p *)p1[ doubly ];
if ( !p2 ) {
p2 = memfile_alloc_block();
if ( !p2 )
ffc11b34: 2c 03 00 00 cmpwi r3,0
ffc11b38: 41 a2 fd cc beq- ffc11904 <IMFS_memfile_get_block_pointer+0x5c><== NEVER TAKEN
return 0;
p1[ doubly ] = (block_p) p2;
ffc11b3c: 90 7c 00 00 stw r3,0(r28)
ffc11b40: 4b ff fe 70 b ffc119b0 <IMFS_memfile_get_block_pointer+0x108>
p = info->doubly_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
ffc11b44: 4b ff fd 21 bl ffc11864 <memfile_alloc_block>
if ( !p )
return 0;
ffc11b48: 3b c0 00 00 li r30,0
p = info->doubly_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
if ( !p )
ffc11b4c: 7c 6b 1b 79 mr. r11,r3
ffc11b50: 41 a2 fd b4 beq- ffc11904 <IMFS_memfile_get_block_pointer+0x5c><== NEVER TAKEN
return 0;
info->doubly_indirect = p;
ffc11b54: 91 7f 00 5c stw r11,92(r31)
ffc11b58: 4b ff fe ac b ffc11a04 <IMFS_memfile_get_block_pointer+0x15c>
info->triply_indirect = p;
}
p1 = (block_p *) p[ triply ];
if ( !p1 ) {
p1 = memfile_alloc_block();
ffc11b5c: 4b ff fd 09 bl ffc11864 <memfile_alloc_block>
if ( !p1 )
return 0;
ffc11b60: 3b c0 00 00 li r30,0
}
p1 = (block_p *) p[ triply ];
if ( !p1 ) {
p1 = memfile_alloc_block();
if ( !p1 )
ffc11b64: 7c 6b 1b 79 mr. r11,r3
ffc11b68: 41 a2 fd 9c beq- ffc11904 <IMFS_memfile_get_block_pointer+0x5c><== NEVER TAKEN
return 0;
p[ triply ] = (block_p) p1;
ffc11b6c: 91 7d 00 00 stw r11,0(r29)
ffc11b70: 4b ff fe 2c b ffc1199c <IMFS_memfile_get_block_pointer+0xf4>
p = info->triply_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
ffc11b74: 4b ff fc f1 bl ffc11864 <memfile_alloc_block>
if ( !p )
ffc11b78: 7c 6a 1b 79 mr. r10,r3
ffc11b7c: 41 a2 fd 88 beq- ffc11904 <IMFS_memfile_get_block_pointer+0x5c><== NEVER TAKEN
return 0;
info->triply_indirect = p;
ffc11b80: 91 5f 00 60 stw r10,96(r31)
ffc11b84: 4b ff fe 04 b ffc11988 <IMFS_memfile_get_block_pointer+0xe0>
ffc11b88 <IMFS_memfile_read>:
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
ffc11b88: 94 21 ff c0 stwu r1,-64(r1)
ffc11b8c: 7c 08 02 a6 mflr r0
ffc11b90: 90 01 00 44 stw r0,68(r1)
* 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) {
ffc11b94: 80 03 00 4c lwz r0,76(r3)
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
ffc11b98: 93 81 00 30 stw r28,48(r1)
ffc11b9c: 7c fc 3b 78 mr r28,r7
* 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) {
ffc11ba0: 2f 80 00 06 cmpwi cr7,r0,6
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
ffc11ba4: 93 a1 00 34 stw r29,52(r1)
ffc11ba8: 7c 7d 1b 78 mr r29,r3
ffc11bac: 93 c1 00 38 stw r30,56(r1)
ffc11bb0: 7c be 2b 78 mr r30,r5
ffc11bb4: 93 e1 00 3c stw r31,60(r1)
ffc11bb8: 7c df 33 78 mr r31,r6
ffc11bbc: 92 e1 00 1c stw r23,28(r1)
ffc11bc0: 93 01 00 20 stw r24,32(r1)
ffc11bc4: 93 21 00 24 stw r25,36(r1)
ffc11bc8: 93 41 00 28 stw r26,40(r1)
ffc11bcc: 93 61 00 2c stw r27,44(r1)
* 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) {
ffc11bd0: 41 9e 01 d0 beq- cr7,ffc11da0 <IMFS_memfile_read+0x218>
/*
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size )
ffc11bd4: 80 03 00 50 lwz r0,80(r3)
ffc11bd8: 39 20 00 00 li r9,0
ffc11bdc: 83 43 00 54 lwz r26,84(r3)
ffc11be0: 7f 89 00 00 cmpw cr7,r9,r0
/*
* 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;
ffc11be4: 7c c0 33 78 mr r0,r6
ffc11be8: 7d 28 32 14 add r9,r8,r6
if ( last_byte > the_jnode->info.file.size )
ffc11bec: 40 9d 01 28 ble- cr7,ffc11d14 <IMFS_memfile_read+0x18c> <== ALWAYS TAKEN
my_length = the_jnode->info.file.size - start;
ffc11bf0: 7f 40 d0 50 subf r26,r0,r26
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
ffc11bf4: 3f 20 00 00 lis r25,0
ffc11bf8: 83 79 27 e8 lwz r27,10216(r25)
ffc11bfc: 7f c3 f3 78 mr r3,r30
ffc11c00: 7f e4 fb 78 mr r4,r31
ffc11c04: 7f 78 fe 70 srawi r24,r27,31
ffc11c08: 7f 05 c3 78 mr r5,r24
ffc11c0c: 7f 66 db 78 mr r6,r27
ffc11c10: 48 00 bc f1 bl ffc1d900 <__moddi3>
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
ffc11c14: 7f c3 f3 78 mr r3,r30
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
ffc11c18: 7c 97 23 78 mr r23,r4
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
ffc11c1c: 7f 05 c3 78 mr r5,r24
ffc11c20: 7f e4 fb 78 mr r4,r31
ffc11c24: 7f 66 db 78 mr r6,r27
ffc11c28: 48 00 b8 99 bl ffc1d4c0 <__divdi3>
if ( start_offset ) {
ffc11c2c: 2f 97 00 00 cmpwi cr7,r23,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;
ffc11c30: 7c 9e 23 78 mr r30,r4
unsigned int last_byte;
unsigned int copied;
unsigned int start_offset;
unsigned char *dest;
dest = destination;
ffc11c34: 7f 98 e3 78 mr r24,r28
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size )
my_length = the_jnode->info.file.size - start;
copied = 0;
ffc11c38: 3b e0 00 00 li r31,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 ) {
ffc11c3c: 41 9e 00 50 beq- cr7,ffc11c8c <IMFS_memfile_read+0x104>
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 );
ffc11c40: 7f a3 eb 78 mr r3,r29
ffc11c44: 38 a0 00 00 li r5,0
ffc11c48: 4b ff fc 61 bl ffc118a8 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
ffc11c4c: 7c 69 1b 79 mr. r9,r3
return copied;
ffc11c50: 38 60 00 00 li r3,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 )
ffc11c54: 41 82 00 8c beq- ffc11ce0 <IMFS_memfile_read+0x158> <== 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;
ffc11c58: 7f 77 d8 50 subf r27,r23,r27
ffc11c5c: 7f 9a d8 40 cmplw cr7,r26,r27
ffc11c60: 7f 5f d3 78 mr r31,r26
ffc11c64: 41 9d 01 cc bgt- cr7,ffc11e30 <IMFS_memfile_read+0x2a8>
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 );
ffc11c68: 80 89 00 00 lwz r4,0(r9)
ffc11c6c: 7f 83 e3 78 mr r3,r28
ffc11c70: 7f e5 fb 78 mr r5,r31
ffc11c74: 7c 84 ba 14 add r4,r4,r23
ffc11c78: 48 00 2e 51 bl ffc14ac8 <memcpy>
dest += to_copy;
block++;
my_length -= to_copy;
ffc11c7c: 83 79 27 e8 lwz r27,10216(r25)
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
dest += to_copy;
ffc11c80: 7f 1c fa 14 add r24,r28,r31
block++;
ffc11c84: 3b de 00 01 addi r30,r30,1
my_length -= to_copy;
ffc11c88: 7f 5f d0 50 subf r26,r31,r26
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
ffc11c8c: 7f 9a d8 40 cmplw cr7,r26,r27
ffc11c90: 40 bc 00 20 bge+ cr7,ffc11cb0 <IMFS_memfile_read+0x128>
ffc11c94: 48 00 00 8c b ffc11d20 <IMFS_memfile_read+0x198>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
ffc11c98: 80 89 00 00 lwz r4,0(r9)
dest += to_copy;
block++;
my_length -= to_copy;
copied += to_copy;
ffc11c9c: 7f ff da 14 add r31,r31,r27
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
ffc11ca0: 48 00 2e 29 bl ffc14ac8 <memcpy>
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
ffc11ca4: 80 19 27 e8 lwz r0,10216(r25)
ffc11ca8: 7f 80 d0 40 cmplw cr7,r0,r26
ffc11cac: 41 9d 00 74 bgt- cr7,ffc11d20 <IMFS_memfile_read+0x198>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
ffc11cb0: 7f c4 f3 78 mr r4,r30
ffc11cb4: 38 a0 00 00 li r5,0
ffc11cb8: 7f a3 eb 78 mr r3,r29
ffc11cbc: 4b ff fb ed bl ffc118a8 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
dest += to_copy;
block++;
my_length -= to_copy;
ffc11cc0: 7f 5b d0 50 subf r26,r27,r26
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
ffc11cc4: 7c 69 1b 79 mr. r9,r3
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
ffc11cc8: 7f 65 db 78 mr r5,r27
ffc11ccc: 7f 03 c3 78 mr r3,r24
dest += to_copy;
block++;
ffc11cd0: 3b de 00 01 addi r30,r30,1
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
dest += to_copy;
ffc11cd4: 7f 18 da 14 add r24,r24,r27
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
ffc11cd8: 40 82 ff c0 bne+ ffc11c98 <IMFS_memfile_read+0x110> <== ALWAYS TAKEN
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
ffc11cdc: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
}
IMFS_update_atime( the_jnode );
return copied;
}
ffc11ce0: 80 01 00 44 lwz r0,68(r1) <== NOT EXECUTED
ffc11ce4: 82 e1 00 1c lwz r23,28(r1) <== NOT EXECUTED
ffc11ce8: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc11cec: 83 01 00 20 lwz r24,32(r1) <== NOT EXECUTED
ffc11cf0: 83 21 00 24 lwz r25,36(r1) <== NOT EXECUTED
ffc11cf4: 83 41 00 28 lwz r26,40(r1) <== NOT EXECUTED
ffc11cf8: 83 61 00 2c lwz r27,44(r1) <== NOT EXECUTED
ffc11cfc: 83 81 00 30 lwz r28,48(r1) <== NOT EXECUTED
ffc11d00: 83 a1 00 34 lwz r29,52(r1) <== NOT EXECUTED
ffc11d04: 83 c1 00 38 lwz r30,56(r1) <== NOT EXECUTED
ffc11d08: 83 e1 00 3c lwz r31,60(r1) <== NOT EXECUTED
ffc11d0c: 38 21 00 40 addi r1,r1,64 <== NOT EXECUTED
ffc11d10: 4e 80 00 20 blr <== NOT EXECUTED
/*
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size )
ffc11d14: 41 9e 01 0c beq- cr7,ffc11e20 <IMFS_memfile_read+0x298> <== ALWAYS TAKEN
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
ffc11d18: 7d 1a 43 78 mr r26,r8 <== NOT EXECUTED
ffc11d1c: 4b ff fe d8 b ffc11bf4 <IMFS_memfile_read+0x6c> <== NOT EXECUTED
/*
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
ffc11d20: 2f 9a 00 00 cmpwi cr7,r26,0
ffc11d24: 41 9e 00 30 beq- cr7,ffc11d54 <IMFS_memfile_read+0x1cc>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
ffc11d28: 7f a3 eb 78 mr r3,r29
ffc11d2c: 7f c4 f3 78 mr r4,r30
ffc11d30: 38 a0 00 00 li r5,0
ffc11d34: 4b ff fb 75 bl ffc118a8 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
ffc11d38: 2c 03 00 00 cmpwi r3,0
ffc11d3c: 41 a2 ff a0 beq- ffc11cdc <IMFS_memfile_read+0x154> <== NEVER TAKEN
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
ffc11d40: 80 83 00 00 lwz r4,0(r3)
ffc11d44: 7f 45 d3 78 mr r5,r26
ffc11d48: 7f 03 c3 78 mr r3,r24
ffc11d4c: 48 00 2d 7d bl ffc14ac8 <memcpy>
copied += my_length;
ffc11d50: 7f ff d2 14 add r31,r31,r26
}
IMFS_update_atime( the_jnode );
ffc11d54: 38 61 00 08 addi r3,r1,8
ffc11d58: 38 80 00 00 li r4,0
ffc11d5c: 4b ff 35 09 bl ffc05264 <gettimeofday>
ffc11d60: 80 01 00 08 lwz r0,8(r1)
return copied;
ffc11d64: 7f e3 fb 78 mr r3,r31
}
ffc11d68: 82 e1 00 1c lwz r23,28(r1)
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
copied += my_length;
}
IMFS_update_atime( the_jnode );
ffc11d6c: 90 1d 00 40 stw r0,64(r29)
return copied;
}
ffc11d70: 80 01 00 44 lwz r0,68(r1)
ffc11d74: 83 01 00 20 lwz r24,32(r1)
ffc11d78: 7c 08 03 a6 mtlr r0
ffc11d7c: 83 21 00 24 lwz r25,36(r1)
ffc11d80: 83 41 00 28 lwz r26,40(r1)
ffc11d84: 83 61 00 2c lwz r27,44(r1)
ffc11d88: 83 81 00 30 lwz r28,48(r1)
ffc11d8c: 83 a1 00 34 lwz r29,52(r1)
ffc11d90: 83 c1 00 38 lwz r30,56(r1)
ffc11d94: 83 e1 00 3c lwz r31,60(r1)
ffc11d98: 38 21 00 40 addi r1,r1,64
ffc11d9c: 4e 80 00 20 blr
if (the_jnode->type == IMFS_LINEAR_FILE) {
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
ffc11da0: 81 43 00 50 lwz r10,80(r3)
ffc11da4: 38 00 00 00 li r0,0
ffc11da8: 81 63 00 54 lwz r11,84(r3)
my_length = length;
if (the_jnode->type == IMFS_LINEAR_FILE) {
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
ffc11dac: 80 83 00 58 lwz r4,88(r3)
if (my_length > (the_jnode->info.linearfile.size - start))
ffc11db0: 7c ff 58 10 subfc r7,r31,r11
ffc11db4: 7c de 51 10 subfe r6,r30,r10
ffc11db8: 7f 80 30 00 cmpw cr7,r0,r6
ffc11dbc: 40 9d 00 7c ble- cr7,ffc11e38 <IMFS_memfile_read+0x2b0> <== ALWAYS TAKEN
my_length = the_jnode->info.linearfile.size - start;
ffc11dc0: 7f 5f 58 50 subf r26,r31,r11
memcpy(dest, &file_ptr[start], my_length);
ffc11dc4: 7c 84 fa 14 add r4,r4,r31
ffc11dc8: 7f 45 d3 78 mr r5,r26
ffc11dcc: 7f 83 e3 78 mr r3,r28
ffc11dd0: 48 00 2c f9 bl ffc14ac8 <memcpy>
IMFS_update_atime( the_jnode );
ffc11dd4: 38 61 00 08 addi r3,r1,8
ffc11dd8: 38 80 00 00 li r4,0
ffc11ddc: 4b ff 34 89 bl ffc05264 <gettimeofday>
ffc11de0: 80 01 00 08 lwz r0,8(r1)
return my_length;
ffc11de4: 7f 43 d3 78 mr r3,r26
}
IMFS_update_atime( the_jnode );
return copied;
}
ffc11de8: 82 e1 00 1c lwz r23,28(r1)
if (my_length > (the_jnode->info.linearfile.size - start))
my_length = the_jnode->info.linearfile.size - start;
memcpy(dest, &file_ptr[start], my_length);
IMFS_update_atime( the_jnode );
ffc11dec: 90 1d 00 40 stw r0,64(r29)
}
IMFS_update_atime( the_jnode );
return copied;
}
ffc11df0: 80 01 00 44 lwz r0,68(r1)
ffc11df4: 83 01 00 20 lwz r24,32(r1)
ffc11df8: 7c 08 03 a6 mtlr r0
ffc11dfc: 83 21 00 24 lwz r25,36(r1)
ffc11e00: 83 41 00 28 lwz r26,40(r1)
ffc11e04: 83 61 00 2c lwz r27,44(r1)
ffc11e08: 83 81 00 30 lwz r28,48(r1)
ffc11e0c: 83 a1 00 34 lwz r29,52(r1)
ffc11e10: 83 c1 00 38 lwz r30,56(r1)
ffc11e14: 83 e1 00 3c lwz r31,60(r1)
ffc11e18: 38 21 00 40 addi r1,r1,64
ffc11e1c: 4e 80 00 20 blr
/*
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size )
ffc11e20: 7f 89 d0 40 cmplw cr7,r9,r26
ffc11e24: 41 bd fd cc bgt- cr7,ffc11bf0 <IMFS_memfile_read+0x68>
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
ffc11e28: 7d 1a 43 78 mr r26,r8
ffc11e2c: 4b ff fd c8 b ffc11bf4 <IMFS_memfile_read+0x6c>
* 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;
ffc11e30: 7f 7f db 78 mr r31,r27
ffc11e34: 4b ff fe 34 b ffc11c68 <IMFS_memfile_read+0xe0>
if (the_jnode->type == IMFS_LINEAR_FILE) {
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
ffc11e38: 40 9e 00 0c bne- cr7,ffc11e44 <IMFS_memfile_read+0x2bc> <== NEVER TAKEN
ffc11e3c: 7f 88 38 40 cmplw cr7,r8,r7
ffc11e40: 41 9d ff 80 bgt+ cr7,ffc11dc0 <IMFS_memfile_read+0x238> <== ALWAYS TAKEN
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
ffc11e44: 7d 1a 43 78 mr r26,r8 <== NOT EXECUTED
ffc11e48: 4b ff ff 7c b ffc11dc4 <IMFS_memfile_read+0x23c> <== NOT EXECUTED
ffc11f84 <IMFS_memfile_remove>:
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
ffc11f84: 94 21 ff d8 stwu r1,-40(r1)
ffc11f88: 7c 08 02 a6 mflr r0
ffc11f8c: 90 01 00 2c stw r0,44(r1)
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
ffc11f90: 80 03 00 58 lwz r0,88(r3)
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
ffc11f94: 93 c1 00 20 stw r30,32(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;
ffc11f98: 3f c0 00 00 lis r30,0
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
ffc11f9c: 2f 80 00 00 cmpwi cr7,r0,0
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
ffc11fa0: 93 a1 00 1c stw r29,28(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;
ffc11fa4: 83 be 27 e8 lwz r29,10216(r30)
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
ffc11fa8: 93 41 00 10 stw r26,16(r1)
ffc11fac: 7c 7a 1b 78 mr r26,r3
/*
* 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;
ffc11fb0: 57 bd f0 be rlwinm r29,r29,30,2,31
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
ffc11fb4: 93 21 00 0c stw r25,12(r1)
ffc11fb8: 93 61 00 14 stw r27,20(r1)
ffc11fbc: 93 81 00 18 stw r28,24(r1)
ffc11fc0: 93 e1 00 24 stw r31,36(r1)
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
ffc11fc4: 41 9e 00 10 beq- cr7,ffc11fd4 <IMFS_memfile_remove+0x50>
memfile_free_blocks_in_table( &info->indirect, to_free );
ffc11fc8: 38 63 00 58 addi r3,r3,88
ffc11fcc: 7f a4 eb 78 mr r4,r29
ffc11fd0: 4b ff ff 25 bl ffc11ef4 <memfile_free_blocks_in_table>
}
if ( info->doubly_indirect ) {
ffc11fd4: 81 3a 00 5c lwz r9,92(r26)
ffc11fd8: 2f 89 00 00 cmpwi cr7,r9,0
ffc11fdc: 41 9e 00 68 beq- cr7,ffc12044 <IMFS_memfile_remove+0xc0>
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
ffc11fe0: 80 1e 27 e8 lwz r0,10216(r30)
ffc11fe4: 54 0b f0 bf rlwinm. r11,r0,30,2,31
ffc11fe8: 41 82 00 50 beq- ffc12038 <IMFS_memfile_remove+0xb4> <== NEVER TAKEN
ffc11fec: 3f 80 00 00 lis r28,0
ffc11ff0: 38 60 00 00 li r3,0
ffc11ff4: 3b e0 00 00 li r31,0
ffc11ff8: 3b 9c 27 e8 addi r28,r28,10216
ffc11ffc: 48 00 00 08 b ffc12004 <IMFS_memfile_remove+0x80>
ffc12000: 81 3a 00 5c lwz r9,92(r26)
if ( info->doubly_indirect[i] ) {
ffc12004: 54 63 10 3a rlwinm r3,r3,2,0,29
ffc12008: 7c 09 18 2e lwzx r0,r9,r3
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++ ) {
ffc1200c: 3b ff 00 01 addi r31,r31,1
if ( info->doubly_indirect[i] ) {
memfile_free_blocks_in_table(
ffc12010: 7f a4 eb 78 mr r4,r29
memfile_free_blocks_in_table( &info->indirect, to_free );
}
if ( info->doubly_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
if ( info->doubly_indirect[i] ) {
ffc12014: 2f 80 00 00 cmpwi cr7,r0,0
ffc12018: 7c 69 1a 14 add r3,r9,r3
ffc1201c: 41 9e 00 08 beq- cr7,ffc12024 <IMFS_memfile_remove+0xa0><== NEVER TAKEN
memfile_free_blocks_in_table(
ffc12020: 4b ff fe d5 bl ffc11ef4 <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++ ) {
ffc12024: 80 1c 00 00 lwz r0,0(r28)
ffc12028: 7f e3 fb 78 mr r3,r31
ffc1202c: 54 00 f0 be rlwinm r0,r0,30,2,31
ffc12030: 7f 9f 00 40 cmplw cr7,r31,r0
ffc12034: 41 9c ff cc blt+ cr7,ffc12000 <IMFS_memfile_remove+0x7c>
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 );
ffc12038: 38 7a 00 5c addi r3,r26,92
ffc1203c: 7f a4 eb 78 mr r4,r29
ffc12040: 4b ff fe b5 bl ffc11ef4 <memfile_free_blocks_in_table>
}
if ( info->triply_indirect ) {
ffc12044: 80 7a 00 60 lwz r3,96(r26)
ffc12048: 2f 83 00 00 cmpwi cr7,r3,0
ffc1204c: 41 9e 00 b4 beq- cr7,ffc12100 <IMFS_memfile_remove+0x17c>
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
ffc12050: 80 1e 27 e8 lwz r0,10216(r30)
ffc12054: 54 00 f0 bf rlwinm. r0,r0,30,2,31
ffc12058: 41 82 00 9c beq- ffc120f4 <IMFS_memfile_remove+0x170> <== NEVER TAKEN
p = (block_p *) info->triply_indirect[i];
ffc1205c: 83 c3 00 00 lwz r30,0(r3)
if ( !p ) /* ensure we have a valid pointer */
ffc12060: 2f 9e 00 00 cmpwi cr7,r30,0
ffc12064: 41 9e 00 90 beq- cr7,ffc120f4 <IMFS_memfile_remove+0x170><== NEVER TAKEN
ffc12068: 3f 80 00 00 lis r28,0
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
ffc1206c: 3b 20 00 00 li r25,0
if ( !p ) /* ensure we have a valid pointer */
ffc12070: 3b 60 00 00 li r27,0
ffc12074: 3b 9c 27 e8 addi r28,r28,10216
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
ffc12078: 2f 80 00 00 cmpwi cr7,r0,0
ffc1207c: 41 9e 00 44 beq- cr7,ffc120c0 <IMFS_memfile_remove+0x13c><== NEVER TAKEN
ffc12080: 38 60 00 00 li r3,0
ffc12084: 3b e0 00 00 li r31,0
if ( p[j] ) {
ffc12088: 54 63 10 3a rlwinm r3,r3,2,0,29
ffc1208c: 7c 1e 18 2e lwzx r0,r30,r3
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++ ) {
ffc12090: 3b ff 00 01 addi r31,r31,1
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
ffc12094: 7f a4 eb 78 mr r4,r29
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++ ) {
if ( p[j] ) {
ffc12098: 2f 80 00 00 cmpwi cr7,r0,0
ffc1209c: 7c 7e 1a 14 add r3,r30,r3
ffc120a0: 41 9e 00 08 beq- cr7,ffc120a8 <IMFS_memfile_remove+0x124><== NEVER TAKEN
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
ffc120a4: 4b ff fe 51 bl ffc11ef4 <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++ ) {
ffc120a8: 80 1c 00 00 lwz r0,0(r28)
ffc120ac: 7f e3 fb 78 mr r3,r31
ffc120b0: 54 00 f0 be rlwinm r0,r0,30,2,31
ffc120b4: 7f 9f 00 40 cmplw cr7,r31,r0
ffc120b8: 41 9c ff d0 blt+ cr7,ffc12088 <IMFS_memfile_remove+0x104>
ffc120bc: 80 7a 00 60 lwz r3,96(r26)
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
}
}
memfile_free_blocks_in_table(
ffc120c0: 7c 63 ca 14 add r3,r3,r25
ffc120c4: 7f a4 eb 78 mr r4,r29
ffc120c8: 4b ff fe 2d bl ffc11ef4 <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++ ) {
ffc120cc: 80 1c 00 00 lwz r0,0(r28)
ffc120d0: 3b 7b 00 01 addi r27,r27,1
ffc120d4: 54 00 f0 be rlwinm r0,r0,30,2,31
ffc120d8: 7f 9b 00 40 cmplw cr7,r27,r0
ffc120dc: 40 9c 00 18 bge- cr7,ffc120f4 <IMFS_memfile_remove+0x170>
p = (block_p *) info->triply_indirect[i];
ffc120e0: 80 7a 00 60 lwz r3,96(r26)
* a significant difference in the performance of this routine.
*
* Regardless until the IMFS implementation is proven, it
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
ffc120e4: 57 79 10 3a rlwinm r25,r27,2,0,29
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
ffc120e8: 7f c3 c8 2e lwzx r30,r3,r25
if ( !p ) /* ensure we have a valid pointer */
ffc120ec: 2f 9e 00 00 cmpwi cr7,r30,0
ffc120f0: 40 9e ff 88 bne+ cr7,ffc12078 <IMFS_memfile_remove+0xf4><== ALWAYS TAKEN
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
ffc120f4: 38 7a 00 60 addi r3,r26,96
ffc120f8: 7f a4 eb 78 mr r4,r29
ffc120fc: 4b ff fd f9 bl ffc11ef4 <memfile_free_blocks_in_table>
(block_p **)&info->triply_indirect, to_free );
}
return 0;
}
ffc12100: 80 01 00 2c lwz r0,44(r1)
ffc12104: 38 60 00 00 li r3,0
ffc12108: 83 21 00 0c lwz r25,12(r1)
ffc1210c: 7c 08 03 a6 mtlr r0
ffc12110: 83 41 00 10 lwz r26,16(r1)
ffc12114: 83 61 00 14 lwz r27,20(r1)
ffc12118: 83 81 00 18 lwz r28,24(r1)
ffc1211c: 83 a1 00 1c lwz r29,28(r1)
ffc12120: 83 c1 00 20 lwz r30,32(r1)
ffc12124: 83 e1 00 24 lwz r31,36(r1)
ffc12128: 38 21 00 28 addi r1,r1,40
ffc1212c: 4e 80 00 20 blr
ffc12368 <IMFS_memfile_write>:
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
ffc12368: 94 21 ff c0 stwu r1,-64(r1)
ffc1236c: 7c 08 02 a6 mflr r0
ffc12370: 92 e1 00 1c stw r23,28(r1)
ffc12374: 7c f7 3b 78 mr r23,r7
ffc12378: 93 81 00 30 stw r28,48(r1)
ffc1237c: 7c bc 2b 78 mr r28,r5
ffc12380: 93 a1 00 34 stw r29,52(r1)
ffc12384: 7d 1d 43 78 mr r29,r8
ffc12388: 93 c1 00 38 stw r30,56(r1)
ffc1238c: 7c de 33 78 mr r30,r6
/*
* 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;
ffc12390: 7c c8 32 14 add r6,r8,r6
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
ffc12394: 93 e1 00 3c stw r31,60(r1)
ffc12398: 7c 7f 1b 78 mr r31,r3
ffc1239c: 90 01 00 44 stw r0,68(r1)
ffc123a0: 93 01 00 20 stw r24,32(r1)
ffc123a4: 93 21 00 24 stw r25,36(r1)
ffc123a8: 93 41 00 28 stw r26,40(r1)
ffc123ac: 93 61 00 2c stw r27,44(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 ) {
ffc123b0: 80 03 00 50 lwz r0,80(r3)
ffc123b4: 2f 80 00 00 cmpwi cr7,r0,0
ffc123b8: 41 9c 01 b4 blt- cr7,ffc1256c <IMFS_memfile_write+0x204><== NEVER TAKEN
ffc123bc: 41 9e 01 a4 beq- cr7,ffc12560 <IMFS_memfile_write+0x1f8><== ALWAYS TAKEN
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
ffc123c0: 3f 40 00 00 lis r26,0
ffc123c4: 83 7a 27 e8 lwz r27,10216(r26)
ffc123c8: 7f 83 e3 78 mr r3,r28
ffc123cc: 7f c4 f3 78 mr r4,r30
ffc123d0: 7f 79 fe 70 srawi r25,r27,31
ffc123d4: 7f 25 cb 78 mr r5,r25
ffc123d8: 7f 66 db 78 mr r6,r27
ffc123dc: 48 00 b5 25 bl ffc1d900 <__moddi3>
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
ffc123e0: 7f 83 e3 78 mr r3,r28
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
ffc123e4: 7c 98 23 78 mr r24,r4
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
ffc123e8: 7f 25 cb 78 mr r5,r25
ffc123ec: 7f c4 f3 78 mr r4,r30
ffc123f0: 7f 66 db 78 mr r6,r27
ffc123f4: 48 00 b0 cd bl ffc1d4c0 <__divdi3>
if ( start_offset ) {
ffc123f8: 2f 98 00 00 cmpwi cr7,r24,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;
ffc123fc: 7c 9e 23 78 mr r30,r4
status = IMFS_memfile_extend( the_jnode, last_byte );
if ( status )
rtems_set_errno_and_return_minus_one( ENOSPC );
}
copied = 0;
ffc12400: 3b 80 00 00 li r28,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 ) {
ffc12404: 40 9e 00 8c bne- cr7,ffc12490 <IMFS_memfile_write+0x128>
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
ffc12408: 7f 9d d8 40 cmplw cr7,r29,r27
ffc1240c: 40 bc 00 20 bge+ cr7,ffc1242c <IMFS_memfile_write+0xc4>
ffc12410: 48 00 00 cc b ffc124dc <IMFS_memfile_write+0x174>
if ( !block_ptr )
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
ffc12414: 80 63 00 00 lwz r3,0(r3)
* 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(
ffc12418: 7f 9c da 14 add r28,r28,r27
if ( !block_ptr )
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
ffc1241c: 48 00 26 ad bl ffc14ac8 <memcpy>
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
ffc12420: 80 1a 27 e8 lwz r0,10216(r26)
ffc12424: 7f 80 e8 40 cmplw cr7,r0,r29
ffc12428: 41 9d 00 b4 bgt- cr7,ffc124dc <IMFS_memfile_write+0x174>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
ffc1242c: 7f c4 f3 78 mr r4,r30
ffc12430: 38 a0 00 00 li r5,0
ffc12434: 7f e3 fb 78 mr r3,r31
ffc12438: 4b ff f4 71 bl ffc118a8 <IMFS_memfile_get_block_pointer>
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
src += to_copy;
block++;
my_length -= to_copy;
ffc1243c: 7f bb e8 50 subf r29,r27,r29
*/
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 )
ffc12440: 2c 03 00 00 cmpwi r3,0
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
ffc12444: 7e e4 bb 78 mr r4,r23
ffc12448: 7f 65 db 78 mr r5,r27
src += to_copy;
ffc1244c: 7e f7 da 14 add r23,r23,r27
block++;
ffc12450: 3b de 00 01 addi r30,r30,1
*/
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 )
ffc12454: 40 82 ff c0 bne+ ffc12414 <IMFS_memfile_write+0xac> <== ALWAYS TAKEN
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
ffc12458: 80 01 00 44 lwz r0,68(r1)
ffc1245c: 7f 83 e3 78 mr r3,r28
ffc12460: 82 e1 00 1c lwz r23,28(r1)
ffc12464: 7c 08 03 a6 mtlr r0
ffc12468: 83 01 00 20 lwz r24,32(r1)
ffc1246c: 83 21 00 24 lwz r25,36(r1)
ffc12470: 83 41 00 28 lwz r26,40(r1)
ffc12474: 83 61 00 2c lwz r27,44(r1)
ffc12478: 83 81 00 30 lwz r28,48(r1)
ffc1247c: 83 a1 00 34 lwz r29,52(r1)
ffc12480: 83 c1 00 38 lwz r30,56(r1)
ffc12484: 83 e1 00 3c lwz r31,60(r1)
ffc12488: 38 21 00 40 addi r1,r1,64
ffc1248c: 4e 80 00 20 blr
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
ffc12490: 7f e3 fb 78 mr r3,r31
ffc12494: 38 a0 00 00 li r5,0
ffc12498: 4b ff f4 11 bl ffc118a8 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
return copied;
ffc1249c: 3b 80 00 00 li r28,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 )
ffc124a0: 2c 03 00 00 cmpwi r3,0
ffc124a4: 41 a2 ff b4 beq- ffc12458 <IMFS_memfile_write+0xf0> <== 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;
ffc124a8: 7f 98 d8 50 subf r28,r24,r27
ffc124ac: 7f 9c e8 40 cmplw cr7,r28,r29
ffc124b0: 41 9d 00 e4 bgt- cr7,ffc12594 <IMFS_memfile_write+0x22c>
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
ffc124b4: 80 63 00 00 lwz r3,0(r3)
ffc124b8: 7e e4 bb 78 mr r4,r23
ffc124bc: 7f 85 e3 78 mr r5,r28
ffc124c0: 7c 63 c2 14 add r3,r3,r24
ffc124c4: 48 00 26 05 bl ffc14ac8 <memcpy>
src += to_copy;
ffc124c8: 7e f7 e2 14 add r23,r23,r28
block++;
ffc124cc: 3b de 00 01 addi r30,r30,1
my_length -= to_copy;
copied += to_copy;
ffc124d0: 83 7a 27 e8 lwz r27,10216(r26)
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
src += to_copy;
block++;
my_length -= to_copy;
ffc124d4: 7f bc e8 50 subf r29,r28,r29
ffc124d8: 4b ff ff 30 b ffc12408 <IMFS_memfile_write+0xa0>
* 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 ) {
ffc124dc: 2f 9d 00 00 cmpwi cr7,r29,0
ffc124e0: 41 9e 00 30 beq- cr7,ffc12510 <IMFS_memfile_write+0x1a8>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
ffc124e4: 7f e3 fb 78 mr r3,r31
ffc124e8: 7f c4 f3 78 mr r4,r30
ffc124ec: 38 a0 00 00 li r5,0
ffc124f0: 4b ff f3 b9 bl ffc118a8 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
ffc124f4: 2c 03 00 00 cmpwi r3,0
ffc124f8: 41 a2 ff 60 beq- ffc12458 <IMFS_memfile_write+0xf0> <== 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 );
ffc124fc: 80 63 00 00 lwz r3,0(r3)
ffc12500: 7e e4 bb 78 mr r4,r23
ffc12504: 7f a5 eb 78 mr r5,r29
ffc12508: 48 00 25 c1 bl ffc14ac8 <memcpy>
my_length = 0;
copied += to_copy;
ffc1250c: 7f 9c ea 14 add r28,r28,r29
}
IMFS_mtime_ctime_update( the_jnode );
ffc12510: 38 61 00 08 addi r3,r1,8
ffc12514: 38 80 00 00 li r4,0
ffc12518: 4b ff 2d 4d bl ffc05264 <gettimeofday>
ffc1251c: 80 01 00 08 lwz r0,8(r1)
return copied;
}
ffc12520: 7f 83 e3 78 mr r3,r28
ffc12524: 82 e1 00 1c lwz r23,28(r1)
memcpy( &(*block_ptr)[ 0 ], src, my_length );
my_length = 0;
copied += to_copy;
}
IMFS_mtime_ctime_update( the_jnode );
ffc12528: 90 1f 00 44 stw r0,68(r31)
ffc1252c: 90 1f 00 48 stw r0,72(r31)
return copied;
}
ffc12530: 80 01 00 44 lwz r0,68(r1)
ffc12534: 83 01 00 20 lwz r24,32(r1)
ffc12538: 7c 08 03 a6 mtlr r0
ffc1253c: 83 21 00 24 lwz r25,36(r1)
ffc12540: 83 41 00 28 lwz r26,40(r1)
ffc12544: 83 61 00 2c lwz r27,44(r1)
ffc12548: 83 81 00 30 lwz r28,48(r1)
ffc1254c: 83 a1 00 34 lwz r29,52(r1)
ffc12550: 83 c1 00 38 lwz r30,56(r1)
ffc12554: 83 e1 00 3c lwz r31,60(r1)
ffc12558: 38 21 00 40 addi r1,r1,64
ffc1255c: 4e 80 00 20 blr
* 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 ) {
ffc12560: 80 03 00 54 lwz r0,84(r3)
ffc12564: 7f 80 30 40 cmplw cr7,r0,r6
ffc12568: 40 9c fe 58 bge+ cr7,ffc123c0 <IMFS_memfile_write+0x58>
status = IMFS_memfile_extend( the_jnode, last_byte );
ffc1256c: 7f e3 fb 78 mr r3,r31
ffc12570: 38 a0 00 00 li r5,0
ffc12574: 4b ff fb f9 bl ffc1216c <IMFS_memfile_extend>
if ( status )
ffc12578: 2f 83 00 00 cmpwi cr7,r3,0
ffc1257c: 41 9e fe 44 beq+ cr7,ffc123c0 <IMFS_memfile_write+0x58>
rtems_set_errno_and_return_minus_one( ENOSPC );
ffc12580: 48 00 18 0d bl ffc13d8c <__errno>
ffc12584: 38 00 00 1c li r0,28
ffc12588: 90 03 00 00 stw r0,0(r3)
ffc1258c: 3b 80 ff ff li r28,-1
ffc12590: 4b ff fe c8 b ffc12458 <IMFS_memfile_write+0xf0>
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
ffc12594: 80 63 00 00 lwz r3,0(r3)
* 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;
ffc12598: 7f bc eb 78 mr r28,r29
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
ffc1259c: 7e e4 bb 78 mr r4,r23
ffc125a0: 7c 63 c2 14 add r3,r3,r24
ffc125a4: 7f 85 e3 78 mr r5,r28
ffc125a8: 48 00 25 21 bl ffc14ac8 <memcpy>
src += to_copy;
ffc125ac: 7e f7 e2 14 add r23,r23,r28
block++;
ffc125b0: 3b de 00 01 addi r30,r30,1
my_length -= to_copy;
copied += to_copy;
ffc125b4: 83 7a 27 e8 lwz r27,10216(r26)
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
src += to_copy;
block++;
my_length -= to_copy;
ffc125b8: 7f bc e8 50 subf r29,r28,r29
ffc125bc: 4b ff fe 4c b ffc12408 <IMFS_memfile_write+0xa0>
ffc04550 <IMFS_mount>:
#include <rtems/seterr.h>
int IMFS_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
ffc04550: 7c 08 02 a6 mflr r0
ffc04554: 94 21 ff f8 stwu r1,-8(r1)
ffc04558: 90 01 00 0c stw r0,12(r1)
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
ffc0455c: 81 23 00 08 lwz r9,8(r3)
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
ffc04560: 80 09 00 4c lwz r0,76(r9)
ffc04564: 2f 80 00 01 cmpwi cr7,r0,1
ffc04568: 40 9e 00 1c bne- cr7,ffc04584 <IMFS_mount+0x34> <== NEVER TAKEN
/*
* Set mt_fs pointer to point to the mount table entry for
* the mounted file system.
*/
node->info.directory.mt_fs = mt_entry;
ffc0456c: 90 69 00 5c stw r3,92(r9)
return 0;
ffc04570: 38 60 00 00 li r3,0
}
ffc04574: 80 01 00 0c lwz r0,12(r1)
ffc04578: 38 21 00 08 addi r1,r1,8
ffc0457c: 7c 08 03 a6 mtlr r0
ffc04580: 4e 80 00 20 blr
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
ffc04584: 48 00 f8 09 bl ffc13d8c <__errno> <== NOT EXECUTED
ffc04588: 38 00 00 14 li r0,20 <== NOT EXECUTED
ffc0458c: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc04590: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc04594: 4b ff ff e0 b ffc04574 <IMFS_mount+0x24> <== NOT EXECUTED
ffc072c8 <IMFS_print_jnode>:
* This routine prints the contents of the specified jnode.
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
ffc072c8: 94 21 ff f0 stwu r1,-16(r1)
ffc072cc: 7c 08 02 a6 mflr r0
ffc072d0: 93 c1 00 08 stw r30,8(r1)
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
ffc072d4: 3f c0 00 00 lis r30,0
* This routine prints the contents of the specified jnode.
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
ffc072d8: 90 01 00 14 stw r0,20(r1)
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
ffc072dc: 81 3e 27 d4 lwz r9,10196(r30)
* This routine prints the contents of the specified jnode.
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
ffc072e0: 93 e1 00 0c stw r31,12(r1)
ffc072e4: 7c 7f 1b 78 mr r31,r3
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
ffc072e8: 38 63 00 0c addi r3,r3,12
ffc072ec: 80 89 00 08 lwz r4,8(r9)
ffc072f0: 48 01 22 0d bl ffc194fc <fputs>
switch( the_jnode->type ) {
ffc072f4: 80 bf 00 4c lwz r5,76(r31)
ffc072f8: 2b 85 00 07 cmplwi cr7,r5,7
ffc072fc: 40 9d 00 34 ble- cr7,ffc07330 <IMFS_print_jnode+0x68> <== ALWAYS TAKEN
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
return;
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
ffc07300: 81 3e 27 d4 lwz r9,10196(r30) <== NOT EXECUTED
ffc07304: 3c 80 ff c3 lis r4,-61 <== NOT EXECUTED
ffc07308: 38 84 8e bc addi r4,r4,-28996 <== NOT EXECUTED
ffc0730c: 80 69 00 08 lwz r3,8(r9) <== NOT EXECUTED
ffc07310: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc07314: 48 01 1f e5 bl ffc192f8 <fprintf> <== NOT EXECUTED
return;
}
puts("");
}
ffc07318: 80 01 00 14 lwz r0,20(r1) <== NOT EXECUTED
ffc0731c: 83 c1 00 08 lwz r30,8(r1) <== NOT EXECUTED
ffc07320: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc07324: 83 e1 00 0c lwz r31,12(r1) <== NOT EXECUTED
ffc07328: 38 21 00 10 addi r1,r1,16 <== NOT EXECUTED
ffc0732c: 4e 80 00 20 blr <== NOT EXECUTED
)
{
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
switch( the_jnode->type ) {
ffc07330: 3d 20 ff c3 lis r9,-61
ffc07334: 39 29 8e 44 addi r9,r9,-29116
ffc07338: 54 a0 10 3a rlwinm r0,r5,2,0,29
ffc0733c: 7c 09 00 2e lwzx r0,r9,r0
ffc07340: 7d 20 4a 14 add r9,r0,r9
ffc07344: 7d 29 03 a6 mtctr r9
ffc07348: 4e 80 04 20 bctr
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
ffc0734c: 81 3e 27 d4 lwz r9,10196(r30)
ffc07350: 3c 60 ff c3 lis r3,-61
ffc07354: 38 63 8e 94 addi r3,r3,-29036
ffc07358: 80 c9 00 08 lwz r6,8(r9)
ffc0735c: 38 80 00 01 li r4,1
ffc07360: 38 a0 00 13 li r5,19
ffc07364: 48 01 2f b9 bl ffc1a31c <fwrite>
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
}
ffc07368: 80 01 00 14 lwz r0,20(r1)
ffc0736c: 83 c1 00 08 lwz r30,8(r1)
ffc07370: 7c 08 03 a6 mtlr r0
ffc07374: 83 e1 00 0c lwz r31,12(r1)
ffc07378: 38 21 00 10 addi r1,r1,16
ffc0737c: 4e 80 00 20 blr
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
ffc07380: 81 3e 27 d4 lwz r9,10196(r30)
ffc07384: 3c 60 ff c3 lis r3,-61
ffc07388: 38 63 8e a8 addi r3,r3,-29016
ffc0738c: 80 c9 00 08 lwz r6,8(r9)
ffc07390: 38 80 00 01 li r4,1
ffc07394: 38 a0 00 12 li r5,18
ffc07398: 48 01 2f 85 bl ffc1a31c <fwrite>
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
}
ffc0739c: 80 01 00 14 lwz r0,20(r1)
ffc073a0: 83 c1 00 08 lwz r30,8(r1)
ffc073a4: 7c 08 03 a6 mtlr r0
ffc073a8: 83 e1 00 0c lwz r31,12(r1)
ffc073ac: 38 21 00 10 addi r1,r1,16
ffc073b0: 4e 80 00 20 blr
the_jnode->info.file.indirect,
the_jnode->info.file.doubly_indirect,
the_jnode->info.file.triply_indirect
);
#else
fprintf(stdout, " (file %" PRId32 ")",
ffc073b4: 81 3e 27 d4 lwz r9,10196(r30)
ffc073b8: 3c 80 ff c3 lis r4,-61
ffc073bc: 80 bf 00 54 lwz r5,84(r31)
ffc073c0: 38 84 8e 88 addi r4,r4,-29048
ffc073c4: 80 69 00 08 lwz r3,8(r9)
ffc073c8: 4c c6 31 82 crclr 4*cr1+eq
ffc073cc: 48 01 1f 2d bl ffc192f8 <fprintf>
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
ffc073d0: 3c 60 ff c2 lis r3,-62
ffc073d4: 38 63 7f fc addi r3,r3,32764
ffc073d8: 48 01 41 d1 bl ffc1b5a8 <puts>
}
ffc073dc: 80 01 00 14 lwz r0,20(r1)
ffc073e0: 83 c1 00 08 lwz r30,8(r1)
ffc073e4: 7c 08 03 a6 mtlr r0
ffc073e8: 83 e1 00 0c lwz r31,12(r1)
ffc073ec: 38 21 00 10 addi r1,r1,16
ffc073f0: 4e 80 00 20 blr
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
case IMFS_LINEAR_FILE:
fprintf(stdout, " (file %" PRId32 " %p)",
ffc073f4: 81 3e 27 d4 lwz r9,10196(r30)
ffc073f8: 3c 80 ff c3 lis r4,-61
ffc073fc: 80 bf 00 54 lwz r5,84(r31)
ffc07400: 38 84 8e 78 addi r4,r4,-29064
ffc07404: 80 69 00 08 lwz r3,8(r9)
ffc07408: 80 df 00 58 lwz r6,88(r31)
ffc0740c: 4c c6 31 82 crclr 4*cr1+eq
ffc07410: 48 01 1e e9 bl ffc192f8 <fprintf>
(uint32_t)the_jnode->info.linearfile.size,
the_jnode->info.linearfile.direct
);
break;
ffc07414: 4b ff ff bc b ffc073d0 <IMFS_print_jnode+0x108>
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
switch( the_jnode->type ) {
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
ffc07418: 81 3e 27 d4 lwz r9,10196(r30)
ffc0741c: 38 60 00 2f li r3,47
ffc07420: 80 89 00 08 lwz r4,8(r9)
ffc07424: 48 01 1f bd bl ffc193e0 <fputc>
break;
ffc07428: 4b ff ff a8 b ffc073d0 <IMFS_print_jnode+0x108>
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
ffc0742c: 81 3e 27 d4 lwz r9,10196(r30)
ffc07430: 3c 80 ff c3 lis r4,-61
ffc07434: 80 bf 00 50 lwz r5,80(r31)
ffc07438: 38 84 8e 64 addi r4,r4,-29084
ffc0743c: 80 69 00 08 lwz r3,8(r9)
ffc07440: 80 df 00 54 lwz r6,84(r31)
ffc07444: 4c c6 31 82 crclr 4*cr1+eq
ffc07448: 48 01 1e b1 bl ffc192f8 <fprintf>
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
ffc0744c: 4b ff ff 84 b ffc073d0 <IMFS_print_jnode+0x108>
ffc045f4 <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 */
)
{
ffc045f4: 94 21 ff e0 stwu r1,-32(r1)
ffc045f8: 7c 08 02 a6 mflr r0
ffc045fc: 90 01 00 24 stw r0,36(r1)
ffc04600: 93 e1 00 1c stw r31,28(r1)
IMFS_jnode_t *the_jnode;
IMFS_jnode_t *new_parent;
the_jnode = old_loc->node_access;
ffc04604: 83 e4 00 00 lwz r31,0(r4)
strncpy( the_jnode->name, new_name, IMFS_NAME_MAX );
ffc04608: 7c c4 33 78 mr r4,r6
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 */
)
{
ffc0460c: 93 c1 00 18 stw r30,24(r1)
ffc04610: 7c be 2b 78 mr r30,r5
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 );
ffc04614: 38 7f 00 0c addi r3,r31,12
ffc04618: 38 a0 00 20 li r5,32
ffc0461c: 48 01 11 59 bl ffc15774 <strncpy>
if ( the_jnode->Parent != NULL )
ffc04620: 80 1f 00 08 lwz r0,8(r31)
ffc04624: 2f 80 00 00 cmpwi cr7,r0,0
ffc04628: 41 9e 00 0c beq- cr7,ffc04634 <IMFS_rename+0x40> <== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
ffc0462c: 7f e3 fb 78 mr r3,r31
ffc04630: 48 00 5b ed bl ffc0a21c <_Chain_Extract>
rtems_chain_extract( (rtems_chain_node *) the_jnode );
new_parent = new_parent_loc->node_access;
ffc04634: 80 7e 00 00 lwz r3,0(r30)
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
ffc04638: 7f e4 fb 78 mr r4,r31
the_jnode->Parent = new_parent;
ffc0463c: 90 7f 00 08 stw r3,8(r31)
ffc04640: 38 63 00 50 addi r3,r3,80
ffc04644: 48 00 5b a9 bl ffc0a1ec <_Chain_Append>
rtems_chain_append( &new_parent->info.directory.Entries, &the_jnode->Node );
/*
* Update the time.
*/
IMFS_update_ctime( the_jnode );
ffc04648: 38 61 00 08 addi r3,r1,8
ffc0464c: 38 80 00 00 li r4,0
ffc04650: 48 00 0c 15 bl ffc05264 <gettimeofday>
ffc04654: 80 01 00 08 lwz r0,8(r1)
return 0;
}
ffc04658: 38 60 00 00 li r3,0
ffc0465c: 83 c1 00 18 lwz r30,24(r1)
rtems_chain_append( &new_parent->info.directory.Entries, &the_jnode->Node );
/*
* Update the time.
*/
IMFS_update_ctime( the_jnode );
ffc04660: 90 1f 00 48 stw r0,72(r31)
return 0;
}
ffc04664: 80 01 00 24 lwz r0,36(r1)
ffc04668: 83 e1 00 1c lwz r31,28(r1)
ffc0466c: 38 21 00 20 addi r1,r1,32
ffc04670: 7c 08 03 a6 mtlr r0
ffc04674: 4e 80 00 20 blr
ffc0e0f4 <IMFS_skip_separator>:
static void IMFS_skip_separator (
const char *path, /* IN */
size_t *len, /* IN/OUT */
int *index /* IN/OUT */
)
{
ffc0e0f4: 94 21 ff e8 stwu r1,-24(r1)
ffc0e0f8: 7c 08 02 a6 mflr r0
ffc0e0fc: 93 a1 00 0c stw r29,12(r1)
ffc0e100: 7c bd 2b 78 mr r29,r5
ffc0e104: 93 c1 00 10 stw r30,16(r1)
ffc0e108: 7c 9e 23 78 mr r30,r4
ffc0e10c: 93 e1 00 14 stw r31,20(r1)
ffc0e110: 7c 7f 1b 78 mr r31,r3
ffc0e114: 90 01 00 1c stw r0,28(r1)
while ( IMFS_is_separator( path[*index] ) && path[*index] && *len ) {
ffc0e118: 48 00 00 34 b ffc0e14c <IMFS_skip_separator+0x58>
ffc0e11c: 81 3d 00 00 lwz r9,0(r29)
ffc0e120: 7c 1f 48 ae lbzx r0,r31,r9
++(*index);
ffc0e124: 39 29 00 01 addi r9,r9,1
const char *path, /* IN */
size_t *len, /* IN/OUT */
int *index /* IN/OUT */
)
{
while ( IMFS_is_separator( path[*index] ) && path[*index] && *len ) {
ffc0e128: 2f 80 00 00 cmpwi cr7,r0,0
ffc0e12c: 41 9e 00 34 beq- cr7,ffc0e160 <IMFS_skip_separator+0x6c>
ffc0e130: 80 1e 00 00 lwz r0,0(r30)
ffc0e134: 2f 80 00 00 cmpwi cr7,r0,0
ffc0e138: 41 9e 00 28 beq- cr7,ffc0e160 <IMFS_skip_separator+0x6c><== NEVER TAKEN
++(*index);
ffc0e13c: 91 3d 00 00 stw r9,0(r29)
--(*len);
ffc0e140: 81 3e 00 00 lwz r9,0(r30)
ffc0e144: 38 09 ff ff addi r0,r9,-1
ffc0e148: 90 1e 00 00 stw r0,0(r30)
const char *path, /* IN */
size_t *len, /* IN/OUT */
int *index /* IN/OUT */
)
{
while ( IMFS_is_separator( path[*index] ) && path[*index] && *len ) {
ffc0e14c: 80 1d 00 00 lwz r0,0(r29)
ffc0e150: 7c 7f 00 ae lbzx r3,r31,r0
ffc0e154: 4b ff 83 9d bl ffc064f0 <rtems_filesystem_is_separator>
ffc0e158: 2f 83 00 00 cmpwi cr7,r3,0
ffc0e15c: 40 9e ff c0 bne+ cr7,ffc0e11c <IMFS_skip_separator+0x28>
++(*index);
--(*len);
}
}
ffc0e160: 80 01 00 1c lwz r0,28(r1)
ffc0e164: 83 a1 00 0c lwz r29,12(r1)
ffc0e168: 7c 08 03 a6 mtlr r0
ffc0e16c: 83 c1 00 10 lwz r30,16(r1)
ffc0e170: 83 e1 00 14 lwz r31,20(r1)
ffc0e174: 38 21 00 18 addi r1,r1,24
ffc0e178: 4e 80 00 20 blr
ffc0f178 <IMFS_stat>:
int IMFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
ffc0f178: 94 21 ff f0 stwu r1,-16(r1)
ffc0f17c: 7c 08 02 a6 mflr r0
ffc0f180: 90 01 00 14 stw r0,20(r1)
IMFS_fs_info_t *fs_info;
IMFS_jnode_t *the_jnode;
IMFS_device_t *io;
the_jnode = loc->node_access;
ffc0f184: 81 23 00 00 lwz r9,0(r3)
int IMFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
ffc0f188: 93 e1 00 0c stw r31,12(r1)
IMFS_device_t *io;
the_jnode = loc->node_access;
switch ( the_jnode->type ) {
ffc0f18c: 80 09 00 4c lwz r0,76(r9)
ffc0f190: 2b 80 00 07 cmplwi cr7,r0,7
ffc0f194: 40 9d 00 28 ble- cr7,ffc0f1bc <IMFS_stat+0x44> <== ALWAYS TAKEN
case IMFS_FIFO:
buf->st_size = 0;
break;
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
ffc0f198: 48 00 4b f5 bl ffc13d8c <__errno>
ffc0f19c: 38 00 00 86 li r0,134
ffc0f1a0: 90 03 00 00 stw r0,0(r3)
ffc0f1a4: 38 60 ff ff li r3,-1
buf->st_ctime = the_jnode->stat_ctime;
buf->st_blksize = imfs_rq_memfile_bytes_per_block;
return 0;
}
ffc0f1a8: 80 01 00 14 lwz r0,20(r1)
ffc0f1ac: 83 e1 00 0c lwz r31,12(r1)
ffc0f1b0: 38 21 00 10 addi r1,r1,16
ffc0f1b4: 7c 08 03 a6 mtlr r0
ffc0f1b8: 4e 80 00 20 blr
IMFS_device_t *io;
the_jnode = loc->node_access;
switch ( the_jnode->type ) {
ffc0f1bc: 3d 60 ff c2 lis r11,-62
ffc0f1c0: 39 6b 0e 58 addi r11,r11,3672
ffc0f1c4: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc0f1c8: 7c 0b 00 2e lwzx r0,r11,r0
ffc0f1cc: 7d 60 5a 14 add r11,r0,r11
ffc0f1d0: 7d 69 03 a6 mtctr r11
ffc0f1d4: 4e 80 04 20 bctr
case IMFS_SYM_LINK:
buf->st_size = 0;
break;
case IMFS_FIFO:
buf->st_size = 0;
ffc0f1d8: 39 40 00 00 li r10,0
ffc0f1dc: 39 60 00 00 li r11,0
ffc0f1e0: 91 44 00 20 stw r10,32(r4)
ffc0f1e4: 91 64 00 24 stw r11,36(r4)
/*
* The device number of the IMFS is the major number and the minor is the
* instance.
*/
fs_info = loc->mt_entry->fs_info;
ffc0f1e8: 81 63 00 10 lwz r11,16(r3)
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
buf->st_ctime = the_jnode->stat_ctime;
buf->st_blksize = imfs_rq_memfile_bytes_per_block;
ffc0f1ec: 3c 60 00 00 lis r3,0
ffc0f1f0: 80 03 27 38 lwz r0,10040(r3)
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
ffc0f1f4: 38 60 00 00 li r3,0
* The device number of the IMFS is the major number and the minor is the
* instance.
*/
fs_info = loc->mt_entry->fs_info;
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
ffc0f1f8: 81 6b 00 34 lwz r11,52(r11)
ffc0f1fc: 60 63 ff fe ori r3,r3,65534
buf->st_mode = the_jnode->st_mode;
ffc0f200: 81 89 00 30 lwz r12,48(r9)
* The device number of the IMFS is the major number and the minor is the
* instance.
*/
fs_info = loc->mt_entry->fs_info;
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
ffc0f204: 83 eb 00 00 lwz r31,0(r11)
buf->st_mode = the_jnode->st_mode;
buf->st_nlink = the_jnode->st_nlink;
ffc0f208: a0 a9 00 34 lhz r5,52(r9)
buf->st_ino = the_jnode->st_ino;
ffc0f20c: 80 c9 00 38 lwz r6,56(r9)
buf->st_uid = the_jnode->st_uid;
ffc0f210: a0 e9 00 3c lhz r7,60(r9)
buf->st_gid = the_jnode->st_gid;
ffc0f214: a1 09 00 3e lhz r8,62(r9)
buf->st_atime = the_jnode->stat_atime;
ffc0f218: 81 49 00 40 lwz r10,64(r9)
buf->st_mtime = the_jnode->stat_mtime;
ffc0f21c: 81 69 00 44 lwz r11,68(r9)
buf->st_ctime = the_jnode->stat_ctime;
ffc0f220: 81 29 00 48 lwz r9,72(r9)
buf->st_blksize = imfs_rq_memfile_bytes_per_block;
ffc0f224: 90 04 00 40 stw r0,64(r4)
return 0;
}
ffc0f228: 80 01 00 14 lwz r0,20(r1)
/*
* 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 =
ffc0f22c: 90 64 00 00 stw r3,0(r4)
buf->st_mtime = the_jnode->stat_mtime;
buf->st_ctime = the_jnode->stat_ctime;
buf->st_blksize = imfs_rq_memfile_bytes_per_block;
return 0;
ffc0f230: 38 60 00 00 li r3,0
}
ffc0f234: 7c 08 03 a6 mtlr r0
/*
* 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 =
ffc0f238: 93 e4 00 04 stw r31,4(r4)
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
ffc0f23c: 91 84 00 0c stw r12,12(r4)
buf->st_ctime = the_jnode->stat_ctime;
buf->st_blksize = imfs_rq_memfile_bytes_per_block;
return 0;
}
ffc0f240: 83 e1 00 0c lwz r31,12(r1)
ffc0f244: 38 21 00 10 addi r1,r1,16
fs_info = loc->mt_entry->fs_info;
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
buf->st_nlink = the_jnode->st_nlink;
ffc0f248: b0 a4 00 10 sth r5,16(r4)
buf->st_ino = the_jnode->st_ino;
ffc0f24c: 90 c4 00 08 stw r6,8(r4)
buf->st_uid = the_jnode->st_uid;
ffc0f250: b0 e4 00 12 sth r7,18(r4)
buf->st_gid = the_jnode->st_gid;
ffc0f254: b1 04 00 14 sth r8,20(r4)
buf->st_atime = the_jnode->stat_atime;
ffc0f258: 91 44 00 28 stw r10,40(r4)
buf->st_mtime = the_jnode->stat_mtime;
ffc0f25c: 91 64 00 30 stw r11,48(r4)
buf->st_ctime = the_jnode->stat_ctime;
ffc0f260: 91 24 00 38 stw r9,56(r4)
buf->st_blksize = imfs_rq_memfile_bytes_per_block;
return 0;
}
ffc0f264: 4e 80 00 20 blr
switch ( the_jnode->type ) {
case IMFS_DEVICE:
io = &the_jnode->info.device;
buf->st_rdev = rtems_filesystem_make_dev_t( io->major, io->minor );
ffc0f268: 81 69 00 54 lwz r11,84(r9)
ffc0f26c: 80 09 00 50 lwz r0,80(r9)
ffc0f270: 91 64 00 1c stw r11,28(r4)
ffc0f274: 90 04 00 18 stw r0,24(r4)
break;
ffc0f278: 4b ff ff 70 b ffc0f1e8 <IMFS_stat+0x70>
case IMFS_LINEAR_FILE:
case IMFS_MEMORY_FILE:
buf->st_size = the_jnode->info.file.size;
ffc0f27c: 81 49 00 50 lwz r10,80(r9)
ffc0f280: 81 69 00 54 lwz r11,84(r9)
ffc0f284: 91 44 00 20 stw r10,32(r4)
ffc0f288: 91 64 00 24 stw r11,36(r4)
break;
ffc0f28c: 4b ff ff 5c b ffc0f1e8 <IMFS_stat+0x70>
ffc0472c <IMFS_unlink>:
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
ffc0472c: 94 21 ff c8 stwu r1,-56(r1)
ffc04730: 7c 08 02 a6 mflr r0
ffc04734: 90 01 00 3c stw r0,60(r1)
ffc04738: 93 c1 00 30 stw r30,48(r1)
IMFS_jnode_t *node;
rtems_filesystem_location_info_t the_link;
int result = 0;
node = loc->node_access;
ffc0473c: 83 c4 00 00 lwz r30,0(r4)
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
ffc04740: 93 a1 00 2c stw r29,44(r1)
ffc04744: 7c 7d 1b 78 mr r29,r3
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
ffc04748: 80 1e 00 4c lwz r0,76(r30)
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
ffc0474c: 93 e1 00 34 stw r31,52(r1)
ffc04750: 7c 9f 23 78 mr r31,r4
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
ffc04754: 2f 80 00 03 cmpwi cr7,r0,3
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
ffc04758: 93 81 00 28 stw r28,40(r1)
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
ffc0475c: 41 9e 00 3c beq- cr7,ffc04798 <IMFS_unlink+0x6c>
/*
* Now actually free the node we were asked to free.
*/
result = (*loc->handlers->rmnod_h)( parentloc, loc );
ffc04760: 81 3f 00 08 lwz r9,8(r31)
ffc04764: 7f a3 eb 78 mr r3,r29
ffc04768: 7f e4 fb 78 mr r4,r31
ffc0476c: 80 09 00 34 lwz r0,52(r9)
ffc04770: 7c 09 03 a6 mtctr r0
ffc04774: 4e 80 04 21 bctrl
return result;
}
ffc04778: 80 01 00 3c lwz r0,60(r1)
ffc0477c: 83 81 00 28 lwz r28,40(r1)
ffc04780: 7c 08 03 a6 mtlr r0
ffc04784: 83 a1 00 2c lwz r29,44(r1)
ffc04788: 83 c1 00 30 lwz r30,48(r1)
ffc0478c: 83 e1 00 34 lwz r31,52(r1)
ffc04790: 38 21 00 38 addi r1,r1,56
ffc04794: 4e 80 00 20 blr
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
if ( !node->info.hard_link.link_node )
ffc04798: 80 1e 00 50 lwz r0,80(r30)
ffc0479c: 2f 80 00 00 cmpwi cr7,r0,0
ffc047a0: 41 9e 00 90 beq- cr7,ffc04830 <IMFS_unlink+0x104> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
the_link = *loc;
the_link.node_access = node->info.hard_link.link_node;
ffc047a4: 7c 3c 0b 78 mr r28,r1
if ( node->type == IMFS_HARD_LINK ) {
if ( !node->info.hard_link.link_node )
rtems_set_errno_and_return_minus_one( EINVAL );
the_link = *loc;
ffc047a8: 81 64 00 08 lwz r11,8(r4)
the_link.node_access = node->info.hard_link.link_node;
ffc047ac: 94 1c 00 10 stwu r0,16(r28)
if ( node->type == IMFS_HARD_LINK ) {
if ( !node->info.hard_link.link_node )
rtems_set_errno_and_return_minus_one( EINVAL );
the_link = *loc;
ffc047b0: 81 24 00 0c lwz r9,12(r4)
the_link.node_access = node->info.hard_link.link_node;
IMFS_Set_handlers( &the_link );
ffc047b4: 7f 83 e3 78 mr r3,r28
if ( node->type == IMFS_HARD_LINK ) {
if ( !node->info.hard_link.link_node )
rtems_set_errno_and_return_minus_one( EINVAL );
the_link = *loc;
ffc047b8: 81 44 00 04 lwz r10,4(r4)
ffc047bc: 80 04 00 10 lwz r0,16(r4)
ffc047c0: 91 61 00 18 stw r11,24(r1)
ffc047c4: 91 21 00 1c stw r9,28(r1)
ffc047c8: 91 41 00 14 stw r10,20(r1)
ffc047cc: 90 01 00 20 stw r0,32(r1)
the_link.node_access = node->info.hard_link.link_node;
IMFS_Set_handlers( &the_link );
ffc047d0: 48 00 99 ad bl ffc0e17c <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)
ffc047d4: 81 3e 00 50 lwz r9,80(r30)
ffc047d8: a1 69 00 34 lhz r11,52(r9)
ffc047dc: 2f 8b 00 01 cmpwi cr7,r11,1
ffc047e0: 41 9e 00 28 beq- cr7,ffc04808 <IMFS_unlink+0xdc>
if ( result != 0 )
return -1;
}
else
{
node->info.hard_link.link_node->st_nlink --;
ffc047e4: 39 6b ff ff addi r11,r11,-1
ffc047e8: b1 69 00 34 sth r11,52(r9)
IMFS_update_ctime( node->info.hard_link.link_node );
ffc047ec: 38 61 00 08 addi r3,r1,8
ffc047f0: 38 80 00 00 li r4,0
ffc047f4: 48 00 0a 71 bl ffc05264 <gettimeofday>
ffc047f8: 81 3e 00 50 lwz r9,80(r30)
ffc047fc: 80 01 00 08 lwz r0,8(r1)
ffc04800: 90 09 00 48 stw r0,72(r9)
ffc04804: 4b ff ff 5c b ffc04760 <IMFS_unlink+0x34>
* to remove the node that is a link and the node itself.
*/
if ( node->info.hard_link.link_node->st_nlink == 1)
{
result = (*the_link.handlers->rmnod_h)( parentloc, &the_link );
ffc04808: 81 21 00 18 lwz r9,24(r1)
ffc0480c: 7f a3 eb 78 mr r3,r29
ffc04810: 7f 84 e3 78 mr r4,r28
ffc04814: 80 09 00 34 lwz r0,52(r9)
ffc04818: 7c 09 03 a6 mtctr r0
ffc0481c: 4e 80 04 21 bctrl
if ( result != 0 )
ffc04820: 2f 83 00 00 cmpwi cr7,r3,0
return -1;
ffc04824: 38 60 ff ff li r3,-1
*/
if ( node->info.hard_link.link_node->st_nlink == 1)
{
result = (*the_link.handlers->rmnod_h)( parentloc, &the_link );
if ( result != 0 )
ffc04828: 41 9e ff 38 beq+ cr7,ffc04760 <IMFS_unlink+0x34>
ffc0482c: 4b ff ff 4c b ffc04778 <IMFS_unlink+0x4c>
*/
if ( node->type == IMFS_HARD_LINK ) {
if ( !node->info.hard_link.link_node )
rtems_set_errno_and_return_minus_one( EINVAL );
ffc04830: 48 00 f5 5d bl ffc13d8c <__errno> <== NOT EXECUTED
ffc04834: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc04838: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc0483c: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc04840: 4b ff ff 38 b ffc04778 <IMFS_unlink+0x4c> <== NOT EXECUTED
ffc04844 <IMFS_unmount>:
#include <rtems/seterr.h>
int IMFS_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
ffc04844: 7c 08 02 a6 mflr r0
ffc04848: 94 21 ff f8 stwu r1,-8(r1)
ffc0484c: 90 01 00 0c stw r0,12(r1)
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
ffc04850: 81 23 00 08 lwz r9,8(r3)
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
ffc04854: 80 09 00 4c lwz r0,76(r9)
ffc04858: 2f 80 00 01 cmpwi cr7,r0,1
ffc0485c: 40 9e 00 2c bne- cr7,ffc04888 <IMFS_unmount+0x44> <== NEVER TAKEN
/*
* Did the node indicate that there was a directory mounted here?
*/
if ( node->info.directory.mt_fs == NULL )
ffc04860: 80 09 00 5c lwz r0,92(r9)
ffc04864: 2f 80 00 00 cmpwi cr7,r0,0
ffc04868: 41 9e 00 34 beq- cr7,ffc0489c <IMFS_unmount+0x58> <== NEVER TAKEN
/*
* 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;
ffc0486c: 38 00 00 00 li r0,0
ffc04870: 90 09 00 5c stw r0,92(r9)
return 0;
ffc04874: 38 60 00 00 li r3,0
}
ffc04878: 80 01 00 0c lwz r0,12(r1)
ffc0487c: 38 21 00 08 addi r1,r1,8
ffc04880: 7c 08 03 a6 mtlr r0
ffc04884: 4e 80 00 20 blr
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
ffc04888: 48 00 f5 05 bl ffc13d8c <__errno> <== NOT EXECUTED
ffc0488c: 38 00 00 14 li r0,20 <== NOT EXECUTED
ffc04890: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc04894: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc04898: 4b ff ff e0 b ffc04878 <IMFS_unmount+0x34> <== NOT EXECUTED
/*
* Did the node indicate that there was a directory mounted here?
*/
if ( node->info.directory.mt_fs == NULL )
rtems_set_errno_and_return_minus_one( EINVAL ); /* XXX */
ffc0489c: 48 00 f4 f1 bl ffc13d8c <__errno> <== NOT EXECUTED
ffc048a0: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc048a4: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc048a8: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc048ac: 4b ff ff cc b ffc04878 <IMFS_unmount+0x34> <== NOT EXECUTED
ffc0549c <RTEMS_Malloc_Initialize>:
)
{
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers != NULL ) {
ffc0549c: 3d 20 00 00 lis r9,0
void RTEMS_Malloc_Initialize(
void *heap_begin,
uintptr_t heap_size,
size_t sbrk_amount
)
{
ffc054a0: 94 21 ff e8 stwu r1,-24(r1)
ffc054a4: 7c 08 02 a6 mflr r0
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers != NULL ) {
ffc054a8: 81 29 27 ac lwz r9,10156(r9)
void RTEMS_Malloc_Initialize(
void *heap_begin,
uintptr_t heap_size,
size_t sbrk_amount
)
{
ffc054ac: 93 a1 00 0c stw r29,12(r1)
ffc054b0: 7c 9d 23 78 mr r29,r4
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers != NULL ) {
ffc054b4: 2f 89 00 00 cmpwi cr7,r9,0
void RTEMS_Malloc_Initialize(
void *heap_begin,
uintptr_t heap_size,
size_t sbrk_amount
)
{
ffc054b8: 93 c1 00 10 stw r30,16(r1)
ffc054bc: 7c 7e 1b 78 mr r30,r3
ffc054c0: 93 e1 00 14 stw r31,20(r1)
ffc054c4: 7c bf 2b 78 mr r31,r5
ffc054c8: 90 01 00 1c stw r0,28(r1)
ffc054cc: 93 81 00 08 stw r28,8(r1)
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers != NULL ) {
ffc054d0: 41 9e 00 10 beq- cr7,ffc054e0 <RTEMS_Malloc_Initialize+0x44>
(*rtems_malloc_statistics_helpers->initialize)();
ffc054d4: 80 09 00 00 lwz r0,0(r9)
ffc054d8: 7c 09 03 a6 mtctr r0
ffc054dc: 4e 80 04 21 bctrl
}
/*
* Initialize the garbage collection list to start with nothing on it.
*/
malloc_deferred_frees_initialize();
ffc054e0: 4b ff ff 2d bl ffc0540c <malloc_deferred_frees_initialize>
/*
* Initialize the optional sbrk support for extending the heap
*/
if ( rtems_malloc_sbrk_helpers != NULL ) {
ffc054e4: 3d 20 00 00 lis r9,0
ffc054e8: 81 29 27 a8 lwz r9,10152(r9)
ffc054ec: 2f 89 00 00 cmpwi cr7,r9,0
ffc054f0: 41 9e 00 24 beq- cr7,ffc05514 <RTEMS_Malloc_Initialize+0x78>
void *new_heap_begin = (*rtems_malloc_sbrk_helpers->initialize)(
ffc054f4: 80 09 00 00 lwz r0,0(r9)
ffc054f8: 7f c3 f3 78 mr r3,r30
ffc054fc: 7f e4 fb 78 mr r4,r31
ffc05500: 7c 09 03 a6 mtctr r0
heap_begin,
sbrk_amount
);
heap_size -= (uintptr_t) new_heap_begin - (uintptr_t) heap_begin;
ffc05504: 7f be ea 14 add r29,r30,r29
/*
* Initialize the optional sbrk support for extending the heap
*/
if ( rtems_malloc_sbrk_helpers != NULL ) {
void *new_heap_begin = (*rtems_malloc_sbrk_helpers->initialize)(
ffc05508: 4e 80 04 21 bctrl
heap_begin,
sbrk_amount
);
heap_size -= (uintptr_t) new_heap_begin - (uintptr_t) heap_begin;
ffc0550c: 7f a3 e8 50 subf r29,r3,r29
heap_begin = new_heap_begin;
ffc05510: 7c 7e 1b 78 mr r30,r3
* of the time under UNIX because zero'ing memory when it is first
* given to a process eliminates the chance of a process seeing data
* left over from another process. This would be a security violation.
*/
if (
ffc05514: 3f 80 00 00 lis r28,0
ffc05518: 88 1c 27 b0 lbz r0,10160(r28)
ffc0551c: 3f e0 00 00 lis r31,0
ffc05520: 2f 80 00 00 cmpwi cr7,r0,0
ffc05524: 40 9e 00 34 bne- cr7,ffc05558 <RTEMS_Malloc_Initialize+0xbc>
!rtems_unified_work_area
&& rtems_configuration_get_do_zero_of_workspace()
ffc05528: 3d 20 00 00 lis r9,0
ffc0552c: 88 09 20 2c lbz r0,8236(r9)
ffc05530: 2f 80 00 00 cmpwi cr7,r0,0
ffc05534: 40 9e 00 5c bne- cr7,ffc05590 <RTEMS_Malloc_Initialize+0xf4>
void *area_begin,
uintptr_t area_size,
uintptr_t page_size
)
{
return _Heap_Initialize( heap, area_begin, area_size, page_size );
ffc05538: 3f e0 00 00 lis r31,0
ffc0553c: 80 7f 27 2c lwz r3,10028(r31)
ffc05540: 7f c4 f3 78 mr r4,r30
ffc05544: 7f a5 eb 78 mr r5,r29
ffc05548: 38 c0 00 08 li r6,8
ffc0554c: 48 00 55 5d bl ffc0aaa8 <_Heap_Initialize>
RTEMS_Malloc_Heap,
heap_begin,
heap_size,
CPU_HEAP_ALIGNMENT
);
if ( status == 0 ) {
ffc05550: 2f 83 00 00 cmpwi cr7,r3,0
ffc05554: 41 9e 00 5c beq- cr7,ffc055b0 <RTEMS_Malloc_Initialize+0x114>
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
}
}
MSBUMP( space_available, _Protected_heap_Get_size(RTEMS_Malloc_Heap) );
ffc05558: 80 7f 27 2c lwz r3,10028(r31)
ffc0555c: 3f c0 00 00 lis r30,0
ffc05560: 83 fe 2b 60 lwz r31,11104(r30)
ffc05564: 48 00 62 f5 bl ffc0b858 <_Protected_heap_Get_size>
}
ffc05568: 80 01 00 1c lwz r0,28(r1)
if ( status == 0 ) {
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
}
}
MSBUMP( space_available, _Protected_heap_Get_size(RTEMS_Malloc_Heap) );
ffc0556c: 7c 63 fa 14 add r3,r3,r31
}
ffc05570: 83 81 00 08 lwz r28,8(r1)
ffc05574: 7c 08 03 a6 mtlr r0
if ( status == 0 ) {
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
}
}
MSBUMP( space_available, _Protected_heap_Get_size(RTEMS_Malloc_Heap) );
ffc05578: 90 7e 2b 60 stw r3,11104(r30)
}
ffc0557c: 83 a1 00 0c lwz r29,12(r1)
ffc05580: 83 c1 00 10 lwz r30,16(r1)
ffc05584: 83 e1 00 14 lwz r31,20(r1)
ffc05588: 38 21 00 18 addi r1,r1,24
ffc0558c: 4e 80 00 20 blr
if (
!rtems_unified_work_area
&& rtems_configuration_get_do_zero_of_workspace()
) {
memset( heap_begin, 0, heap_size );
ffc05590: 7f c3 f3 78 mr r3,r30
ffc05594: 38 80 00 00 li r4,0
ffc05598: 7f a5 eb 78 mr r5,r29
ffc0559c: 48 00 f6 11 bl ffc14bac <memset>
* Unfortunately we cannot use assert if this fails because if this
* has failed we do not have a heap and if we do not have a heap
* STDIO cannot work because there will be no buffers.
*/
if ( !rtems_unified_work_area ) {
ffc055a0: 88 1c 27 b0 lbz r0,10160(r28)
ffc055a4: 2f 80 00 00 cmpwi cr7,r0,0
ffc055a8: 41 9e ff 90 beq+ cr7,ffc05538 <RTEMS_Malloc_Initialize+0x9c><== ALWAYS TAKEN
ffc055ac: 4b ff ff ac b ffc05558 <RTEMS_Malloc_Initialize+0xbc><== NOT EXECUTED
heap_begin,
heap_size,
CPU_HEAP_ALIGNMENT
);
if ( status == 0 ) {
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
ffc055b0: 38 60 00 1a li r3,26
ffc055b4: 48 00 47 8d bl ffc09d40 <rtems_fatal_error_occurred>
ffc04758 <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
ffc04758: 94 21 ff c0 stwu r1,-64(r1)
ffc0475c: 7c 08 02 a6 mflr r0
ffc04760: 90 01 00 44 stw r0,68(r1)
ffc04764: 93 81 00 30 stw r28,48(r1)
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
size = Stack_check_usable_stack_size(stack);
ffc04768: 83 83 00 b8 lwz r28,184(r3)
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
ffc0476c: 80 e3 00 bc lwz r7,188(r3)
size = Stack_check_usable_stack_size(stack);
ffc04770: 3b 9c ff 80 addi r28,r28,-128
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
ffc04774: 93 41 00 28 stw r26,40(r1)
/*
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
ffc04778: 39 27 01 00 addi r9,r7,256
for (ebase = base + length; base < ebase; base++)
ffc0477c: 57 8a 00 3a rlwinm r10,r28,0,0,29
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
ffc04780: 93 61 00 2c stw r27,44(r1)
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
ffc04784: 7d 49 52 14 add r10,r9,r10
ffc04788: 7f 89 50 40 cmplw cr7,r9,r10
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
ffc0478c: 93 a1 00 34 stw r29,52(r1)
ffc04790: 7c 7b 1b 78 mr r27,r3
ffc04794: 92 e1 00 1c stw r23,28(r1)
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;
ffc04798: 3b a0 00 00 li r29,0
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
ffc0479c: 93 01 00 20 stw r24,32(r1)
ffc047a0: 93 21 00 24 stw r25,36(r1)
ffc047a4: 93 c1 00 38 stw r30,56(r1)
ffc047a8: 93 e1 00 3c stw r31,60(r1)
current = 0;
} else
#endif
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
ffc047ac: 83 43 00 c8 lwz r26,200(r3)
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
ffc047b0: 40 9c 00 38 bge- cr7,ffc047e8 <Stack_check_Dump_threads_usage+0x90><== NEVER TAKEN
if (*base != U32_PATTERN)
ffc047b4: 81 07 01 00 lwz r8,256(r7)
* Try to print out how much stack was actually used by the task.
*/
static void *print_context;
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
ffc047b8: 7d 2b 4b 78 mr r11,r9
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
if (*base != U32_PATTERN)
ffc047bc: 6d 00 5a 5a xoris r0,r8,23130
ffc047c0: 2f 80 a5 a5 cmpwi cr7,r0,-23131
ffc047c4: 41 9e 00 14 beq- cr7,ffc047d8 <Stack_check_Dump_threads_usage+0x80><== ALWAYS TAKEN
ffc047c8: 48 00 00 f8 b ffc048c0 <Stack_check_Dump_threads_usage+0x168><== NOT EXECUTED
ffc047cc: 84 0b 00 04 lwzu r0,4(r11)
ffc047d0: 7f 80 40 00 cmpw cr7,r0,r8
ffc047d4: 40 9e 00 ec bne- cr7,ffc048c0 <Stack_check_Dump_threads_usage+0x168>
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
ffc047d8: 39 29 00 04 addi r9,r9,4
ffc047dc: 7f 8a 48 40 cmplw cr7,r10,r9
ffc047e0: 41 9d ff ec bgt+ cr7,ffc047cc <Stack_check_Dump_threads_usage+0x74><== 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;
ffc047e4: 3b a0 00 00 li r29,0 <== NOT EXECUTED
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
#endif
{
(*print_handler)(
ffc047e8: 3f c0 00 00 lis r30,0
ffc047ec: 82 fb 00 08 lwz r23,8(r27)
ffc047f0: 3b fe 28 f4 addi r31,r30,10484
ffc047f4: 83 3e 28 f4 lwz r25,10484(r30)
ffc047f8: 83 1f 00 04 lwz r24,4(r31)
ffc047fc: 38 80 00 05 li r4,5
ffc04800: 38 a1 00 08 addi r5,r1,8
ffc04804: 7e e3 bb 78 mr r3,r23
ffc04808: 48 00 79 45 bl ffc0c14c <rtems_object_get_name>
ffc0480c: 3c 80 ff c2 lis r4,-62
ffc04810: 7c 66 1b 78 mr r6,r3
ffc04814: 7f 29 03 a6 mtctr r25
ffc04818: 38 84 dc 1c addi r4,r4,-9188
ffc0481c: 7e e5 bb 78 mr r5,r23
ffc04820: 7f 03 c3 78 mr r3,r24
ffc04824: 4c c6 31 82 crclr 4*cr1+eq
ffc04828: 4e 80 04 21 bctrl
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
ffc0482c: 80 db 00 b8 lwz r6,184(r27)
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
ffc04830: 80 1e 28 f4 lwz r0,10484(r30)
ffc04834: 3c 80 ff c2 lis r4,-62
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
ffc04838: 80 bb 00 bc lwz r5,188(r27)
ffc0483c: 38 c6 ff ff addi r6,r6,-1
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
ffc04840: 7c 09 03 a6 mtctr r0
ffc04844: 80 7f 00 04 lwz r3,4(r31)
ffc04848: 38 84 dc 2c addi r4,r4,-9172
ffc0484c: 7c c5 32 14 add r6,r5,r6
ffc04850: 7f 47 d3 78 mr r7,r26
ffc04854: 7f 88 e3 78 mr r8,r28
ffc04858: 4c c6 31 82 crclr 4*cr1+eq
ffc0485c: 4e 80 04 21 bctrl
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
ffc04860: 80 1f 00 08 lwz r0,8(r31)
(*print_handler)( print_context, "Unavailable\n" );
ffc04864: 80 7f 00 04 lwz r3,4(r31)
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
ffc04868: 2f 80 00 00 cmpwi cr7,r0,0
(*print_handler)( print_context, "Unavailable\n" );
ffc0486c: 80 1e 28 f4 lwz r0,10484(r30)
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
ffc04870: 41 9e 00 6c beq- cr7,ffc048dc <Stack_check_Dump_threads_usage+0x184><== NEVER TAKEN
(*print_handler)( print_context, "Unavailable\n" );
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
ffc04874: 3c 80 ff c2 lis r4,-62
ffc04878: 7c 09 03 a6 mtctr r0
ffc0487c: 7f a5 eb 78 mr r5,r29
ffc04880: 38 84 dc 5c addi r4,r4,-9124
ffc04884: 4c c6 31 82 crclr 4*cr1+eq
ffc04888: 4e 80 04 21 bctrl
}
}
ffc0488c: 80 01 00 44 lwz r0,68(r1)
ffc04890: 82 e1 00 1c lwz r23,28(r1)
ffc04894: 7c 08 03 a6 mtlr r0
ffc04898: 83 01 00 20 lwz r24,32(r1)
ffc0489c: 83 21 00 24 lwz r25,36(r1)
ffc048a0: 83 41 00 28 lwz r26,40(r1)
ffc048a4: 83 61 00 2c lwz r27,44(r1)
ffc048a8: 83 81 00 30 lwz r28,48(r1)
ffc048ac: 83 a1 00 34 lwz r29,52(r1)
ffc048b0: 83 c1 00 38 lwz r30,56(r1)
ffc048b4: 83 e1 00 3c lwz r31,60(r1)
ffc048b8: 38 21 00 40 addi r1,r1,64
ffc048bc: 4e 80 00 20 blr
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 )
ffc048c0: 2f 89 00 00 cmpwi cr7,r9,0
used = Stack_check_Calculate_used( low, size, high_water_mark );
else
used = 0;
ffc048c4: 3b a0 00 00 li r29,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 )
ffc048c8: 41 be ff 20 beq- cr7,ffc047e8 <Stack_check_Dump_threads_usage+0x90><== NEVER TAKEN
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
ffc048cc: 3b a7 00 80 addi r29,r7,128
size = Stack_check_usable_stack_size(stack);
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 );
ffc048d0: 7f bd e2 14 add r29,r29,r28
ffc048d4: 7f a9 e8 50 subf r29,r9,r29
ffc048d8: 4b ff ff 10 b ffc047e8 <Stack_check_Dump_threads_usage+0x90>
current,
size
);
if (Stack_check_Initialized == 0) {
(*print_handler)( print_context, "Unavailable\n" );
ffc048dc: 3c 80 ff c2 lis r4,-62 <== NOT EXECUTED
ffc048e0: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc048e4: 38 84 dc 4c addi r4,r4,-9140 <== NOT EXECUTED
ffc048e8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc048ec: 4e 80 04 21 bctrl <== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
}
}
ffc048f0: 80 01 00 44 lwz r0,68(r1) <== NOT EXECUTED
ffc048f4: 82 e1 00 1c lwz r23,28(r1) <== NOT EXECUTED
ffc048f8: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc048fc: 83 01 00 20 lwz r24,32(r1) <== NOT EXECUTED
ffc04900: 83 21 00 24 lwz r25,36(r1) <== NOT EXECUTED
ffc04904: 83 41 00 28 lwz r26,40(r1) <== NOT EXECUTED
ffc04908: 83 61 00 2c lwz r27,44(r1) <== NOT EXECUTED
ffc0490c: 83 81 00 30 lwz r28,48(r1) <== NOT EXECUTED
ffc04910: 83 a1 00 34 lwz r29,52(r1) <== NOT EXECUTED
ffc04914: 83 c1 00 38 lwz r30,56(r1) <== NOT EXECUTED
ffc04918: 83 e1 00 3c lwz r31,60(r1) <== NOT EXECUTED
ffc0491c: 38 21 00 40 addi r1,r1,64 <== NOT EXECUTED
ffc04920: 4e 80 00 20 blr <== NOT EXECUTED
ffc04924 <Stack_check_Initialize>:
static uint32_t pattern[ 4 ] = {
0xFEEDF00D, 0x0BAD0D06, /* FEED FOOD to BAD DOG */
0xDEADF00D, 0x600D0D06 /* DEAD FOOD but GOOD DOG */
};
if ( Stack_check_Initialized )
ffc04924: 3d 00 00 00 lis r8,0 <== NOT EXECUTED
ffc04928: 39 08 28 f4 addi r8,r8,10484 <== NOT EXECUTED
ffc0492c: 80 08 00 08 lwz r0,8(r8) <== NOT EXECUTED
ffc04930: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc04934: 4c 9e 00 20 bnelr cr7 <== NOT EXECUTED
ffc04938: 38 00 00 20 li r0,32 <== NOT EXECUTED
ffc0493c: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc04940: 3d 60 00 00 lis r11,0 <== NOT EXECUTED
ffc04944: 3d 40 ff c2 lis r10,-62 <== NOT EXECUTED
ffc04948: 39 6b 2b 64 addi r11,r11,11108 <== NOT EXECUTED
memset((_stack)->area, BYTE_PATTERN, (_stack)->size)
/*
* Stack_check_Initialize
*/
void Stack_check_Initialize( void )
ffc0494c: 39 20 00 00 li r9,0 <== NOT EXECUTED
ffc04950: 39 4a dc 0c addi r10,r10,-9204 <== NOT EXECUTED
/*
* Dope the pattern and fill areas
*/
p = Stack_check_Pattern.pattern;
for ( i = 0; i < PATTERN_SIZE_WORDS; i++ ) {
p[i] = pattern[ i%4 ];
ffc04954: 55 20 17 3a rlwinm r0,r9,2,28,29 <== NOT EXECUTED
ffc04958: 7c 0a 00 2e lwzx r0,r10,r0 <== NOT EXECUTED
/*
* Dope the pattern and fill areas
*/
p = Stack_check_Pattern.pattern;
for ( i = 0; i < PATTERN_SIZE_WORDS; i++ ) {
ffc0495c: 39 29 00 01 addi r9,r9,1 <== NOT EXECUTED
p[i] = pattern[ i%4 ];
ffc04960: 94 0b 00 04 stwu r0,4(r11) <== NOT EXECUTED
/*
* Dope the pattern and fill areas
*/
p = Stack_check_Pattern.pattern;
for ( i = 0; i < PATTERN_SIZE_WORDS; i++ ) {
ffc04964: 42 00 ff f0 bdnz+ ffc04954 <Stack_check_Initialize+0x30> <== NOT EXECUTED
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
}
#endif
Stack_check_Initialized = 1;
ffc04968: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc0496c: 90 08 00 08 stw r0,8(r8) <== NOT EXECUTED
ffc04970: 4e 80 00 20 blr <== NOT EXECUTED
ffc04a38 <Stack_check_report_blown_task>:
Thread_Control *running,
bool pattern_ok
) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE;
void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok)
{
ffc04a38: 94 21 ff c8 stwu r1,-56(r1)
ffc04a3c: 7c 08 02 a6 mflr r0
ffc04a40: 93 a1 00 2c stw r29,44(r1)
ffc04a44: 7c 7d 1b 78 mr r29,r3
Stack_Control *stack = &running->Start.Initial_stack;
void *pattern_area = Stack_check_Get_pattern(stack);
char name[32];
printk("BLOWN STACK!!!\n");
ffc04a48: 3c 60 ff c2 lis r3,-62
Thread_Control *running,
bool pattern_ok
) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE;
void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok)
{
ffc04a4c: 90 01 00 3c stw r0,60(r1)
Stack_Control *stack = &running->Start.Initial_stack;
void *pattern_area = Stack_check_Get_pattern(stack);
char name[32];
printk("BLOWN STACK!!!\n");
ffc04a50: 38 63 dc 64 addi r3,r3,-9116
Thread_Control *running,
bool pattern_ok
) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE;
void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok)
{
ffc04a54: 93 c1 00 30 stw r30,48(r1)
ffc04a58: 93 e1 00 34 stw r31,52(r1)
ffc04a5c: 7c 9f 23 78 mr r31,r4
Stack_Control *stack = &running->Start.Initial_stack;
void *pattern_area = Stack_check_Get_pattern(stack);
ffc04a60: 83 dd 00 bc lwz r30,188(r29)
char name[32];
printk("BLOWN STACK!!!\n");
ffc04a64: 4c c6 31 82 crclr 4*cr1+eq
ffc04a68: 48 00 25 95 bl ffc06ffc <printk>
printk("task control block: 0x%08" PRIxPTR "\n", running);
ffc04a6c: 3c 60 ff c2 lis r3,-62
ffc04a70: 38 63 dc 74 addi r3,r3,-9100
ffc04a74: 7f a4 eb 78 mr r4,r29
ffc04a78: 4c c6 31 82 crclr 4*cr1+eq
ffc04a7c: 48 00 25 81 bl ffc06ffc <printk>
printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);
ffc04a80: 80 9d 00 08 lwz r4,8(r29)
ffc04a84: 3c 60 ff c2 lis r3,-62
ffc04a88: 38 63 dc 94 addi r3,r3,-9068
ffc04a8c: 4c c6 31 82 crclr 4*cr1+eq
ffc04a90: 48 00 25 6d bl ffc06ffc <printk>
printk(
ffc04a94: 80 9d 00 0c lwz r4,12(r29)
ffc04a98: 3c 60 ff c2 lis r3,-62
ffc04a9c: 38 63 dc a8 addi r3,r3,-9048
ffc04aa0: 4c c6 31 82 crclr 4*cr1+eq
ffc04aa4: 48 00 25 59 bl ffc06ffc <printk>
"task name: 0x%08" PRIx32 "\n",
running->Object.name.name_u32
);
printk(
ffc04aa8: 80 7d 00 08 lwz r3,8(r29)
ffc04aac: 38 a1 00 08 addi r5,r1,8
ffc04ab0: 38 80 00 20 li r4,32
ffc04ab4: 48 00 76 99 bl ffc0c14c <rtems_object_get_name>
ffc04ab8: 7c 64 1b 78 mr r4,r3
ffc04abc: 3c 60 ff c2 lis r3,-62
ffc04ac0: 38 63 dc bc addi r3,r3,-9028
ffc04ac4: 4c c6 31 82 crclr 4*cr1+eq
ffc04ac8: 48 00 25 35 bl ffc06ffc <printk>
);
printk(
"task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n",
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
ffc04acc: 80 bd 00 bc lwz r5,188(r29)
ffc04ad0: 80 9d 00 b8 lwz r4,184(r29)
);
printk(
"task name string: %s\n",
rtems_object_get_name(running->Object.id, sizeof(name), name)
);
printk(
ffc04ad4: 3c 60 ff c2 lis r3,-62
ffc04ad8: 38 63 dc d4 addi r3,r3,-9004
ffc04adc: 7c c5 22 14 add r6,r5,r4
ffc04ae0: 4c c6 31 82 crclr 4*cr1+eq
ffc04ae4: 48 00 25 19 bl ffc06ffc <printk>
"task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n",
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
);
if (!pattern_ok) {
ffc04ae8: 2f 9f 00 00 cmpwi cr7,r31,0
ffc04aec: 41 9e 00 0c beq- cr7,ffc04af8 <Stack_check_report_blown_task+0xc0><== ALWAYS TAKEN
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
rtems_fatal_error_occurred(0x81);
ffc04af0: 38 60 00 81 li r3,129
ffc04af4: 48 00 81 bd bl ffc0ccb0 <rtems_fatal_error_occurred>
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
);
if (!pattern_ok) {
printk(
ffc04af8: 3c 60 ff c2 lis r3,-62
ffc04afc: 38 63 dd 08 addi r3,r3,-8952
ffc04b00: 38 80 00 80 li r4,128
ffc04b04: 38 be 00 08 addi r5,r30,8
ffc04b08: 38 de 00 88 addi r6,r30,136
ffc04b0c: 4c c6 31 82 crclr 4*cr1+eq
ffc04b10: 48 00 24 ed bl ffc06ffc <printk>
ffc04b14: 4b ff ff dc b ffc04af0 <Stack_check_report_blown_task+0xb8>
ffc11158 <TOD_MICROSECONDS_TO_TICKS>:
/**
* We should ensure the ticks not be truncated by integer division. We
* need to have it be greater than or equal to the requested time. It
* should not be shorter.
*/
microseconds_per_tick = rtems_configuration_get_microseconds_per_tick();
ffc11158: 3d 20 00 00 lis r9,0
ffc1115c: 80 09 20 28 lwz r0,8232(r9)
ticks = microseconds / microseconds_per_tick;
ffc11160: 7d 23 03 96 divwu r9,r3,r0
if ( (microseconds % microseconds_per_tick) != 0 )
ffc11164: 7c 09 01 d6 mullw r0,r9,r0
ffc11168: 7f 83 00 00 cmpw cr7,r3,r0
ffc1116c: 41 9e 00 08 beq- cr7,ffc11174 <TOD_MICROSECONDS_TO_TICKS+0x1c><== ALWAYS TAKEN
ticks += 1;
ffc11170: 39 29 00 01 addi r9,r9,1 <== NOT EXECUTED
return ticks;
}
ffc11174: 7d 23 4b 78 mr r3,r9
ffc11178: 4e 80 00 20 blr
ffc0b1d0 <TOD_MILLISECONDS_TO_TICKS>:
/**
* We should ensure the ticks not be truncated by integer division. We
* need to have it be greater than or equal to the requested time. It
* should not be shorter.
*/
milliseconds_per_tick = rtems_configuration_get_milliseconds_per_tick();
ffc0b1d0: 3d 20 00 00 lis r9,0
ffc0b1d4: 81 29 20 10 lwz r9,8208(r9)
ffc0b1d8: 3c 00 10 62 lis r0,4194
ffc0b1dc: 60 00 4d d3 ori r0,r0,19923
ffc0b1e0: 7c 09 00 16 mulhwu r0,r9,r0
ffc0b1e4: 54 00 d1 be rlwinm r0,r0,26,6,31
ticks = milliseconds / milliseconds_per_tick;
ffc0b1e8: 7d 23 03 96 divwu r9,r3,r0
if ( (milliseconds % milliseconds_per_tick) != 0 )
ffc0b1ec: 7c 09 01 d6 mullw r0,r9,r0
ffc0b1f0: 7f 83 00 00 cmpw cr7,r3,r0
ffc0b1f4: 41 9e 00 08 beq- cr7,ffc0b1fc <TOD_MILLISECONDS_TO_TICKS+0x2c><== ALWAYS TAKEN
ticks += 1;
ffc0b1f8: 39 29 00 01 addi r9,r9,1 <== NOT EXECUTED
return ticks;
}
ffc0b1fc: 7d 23 4b 78 mr r3,r9
ffc0b200: 4e 80 00 20 blr
ffc09fcc <_API_extensions_Run_postdriver>:
/*
* _API_extensions_Run_postdriver
*/
void _API_extensions_Run_postdriver( void )
{
ffc09fcc: 94 21 ff f0 stwu r1,-16(r1)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc09fd0: 3d 20 00 00 lis r9,0
ffc09fd4: 7c 08 02 a6 mflr r0
ffc09fd8: 93 c1 00 08 stw r30,8(r1)
ffc09fdc: 3b c9 2e 00 addi r30,r9,11776
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
ffc09fe0: 3b de 00 04 addi r30,r30,4
/*
* _API_extensions_Run_postdriver
*/
void _API_extensions_Run_postdriver( void )
{
ffc09fe4: 93 e1 00 0c stw r31,12(r1)
ffc09fe8: 83 e9 2e 00 lwz r31,11776(r9)
ffc09fec: 90 01 00 14 stw r0,20(r1)
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
ffc09ff0: 7f 9f f0 00 cmpw cr7,r31,r30
ffc09ff4: 41 9e 00 1c beq- cr7,ffc0a010 <_API_extensions_Run_postdriver+0x44><== NEVER TAKEN
* Currently all APIs configure this hook so it is always non-NULL.
*/
#if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API)
if ( the_extension->postdriver_hook )
#endif
(*the_extension->postdriver_hook)();
ffc09ff8: 80 1f 00 08 lwz r0,8(r31)
ffc09ffc: 7c 09 03 a6 mtctr r0
ffc0a000: 4e 80 04 21 bctrl
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
the_node = the_node->next ) {
ffc0a004: 83 ff 00 00 lwz r31,0(r31)
void _API_extensions_Run_postdriver( void )
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
ffc0a008: 7f 9f f0 00 cmpw cr7,r31,r30
ffc0a00c: 40 9e ff ec bne+ cr7,ffc09ff8 <_API_extensions_Run_postdriver+0x2c>
#if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API)
if ( the_extension->postdriver_hook )
#endif
(*the_extension->postdriver_hook)();
}
}
ffc0a010: 80 01 00 14 lwz r0,20(r1)
ffc0a014: 83 c1 00 08 lwz r30,8(r1)
ffc0a018: 7c 08 03 a6 mtlr r0
ffc0a01c: 83 e1 00 0c lwz r31,12(r1)
ffc0a020: 38 21 00 10 addi r1,r1,16
ffc0a024: 4e 80 00 20 blr
ffc0a028 <_API_extensions_Run_postswitch>:
/*
* _API_extensions_Run_postswitch
*/
void _API_extensions_Run_postswitch( void )
{
ffc0a028: 94 21 ff e8 stwu r1,-24(r1)
ffc0a02c: 3d 20 00 00 lis r9,0
ffc0a030: 7c 08 02 a6 mflr r0
ffc0a034: 93 c1 00 10 stw r30,16(r1)
ffc0a038: 3b c9 2e 00 addi r30,r9,11776
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
ffc0a03c: 3b de 00 04 addi r30,r30,4
/*
* _API_extensions_Run_postswitch
*/
void _API_extensions_Run_postswitch( void )
{
ffc0a040: 93 e1 00 14 stw r31,20(r1)
ffc0a044: 83 e9 2e 00 lwz r31,11776(r9)
ffc0a048: 90 01 00 1c stw r0,28(r1)
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
ffc0a04c: 7f 9f f0 00 cmpw cr7,r31,r30
/*
* _API_extensions_Run_postswitch
*/
void _API_extensions_Run_postswitch( void )
{
ffc0a050: 93 a1 00 0c stw r29,12(r1)
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
ffc0a054: 41 9e 00 28 beq- cr7,ffc0a07c <_API_extensions_Run_postswitch+0x54><== NEVER TAKEN
ffc0a058: 3f a0 00 00 lis r29,0
ffc0a05c: 3b bd 31 44 addi r29,r29,12612
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (API_extensions_Control *) the_node;
(*the_extension->postswitch_hook)( _Thread_Executing );
ffc0a060: 80 1f 00 0c lwz r0,12(r31)
ffc0a064: 80 7d 00 0c lwz r3,12(r29)
ffc0a068: 7c 09 03 a6 mtctr r0
ffc0a06c: 4e 80 04 21 bctrl
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
the_node = the_node->next ) {
ffc0a070: 83 ff 00 00 lwz r31,0(r31)
void _API_extensions_Run_postswitch( void )
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
ffc0a074: 7f 9f f0 00 cmpw cr7,r31,r30
ffc0a078: 40 9e ff e8 bne+ cr7,ffc0a060 <_API_extensions_Run_postswitch+0x38>
the_extension = (API_extensions_Control *) the_node;
(*the_extension->postswitch_hook)( _Thread_Executing );
}
}
ffc0a07c: 80 01 00 1c lwz r0,28(r1)
ffc0a080: 83 a1 00 0c lwz r29,12(r1)
ffc0a084: 7c 08 03 a6 mtlr r0
ffc0a088: 83 c1 00 10 lwz r30,16(r1)
ffc0a08c: 83 e1 00 14 lwz r31,20(r1)
ffc0a090: 38 21 00 18 addi r1,r1,24
ffc0a094: 4e 80 00 20 blr
ffc0ca58 <_CORE_RWLock_Release>:
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
ffc0ca58: 94 21 ff f0 stwu r1,-16(r1)
ffc0ca5c: 7c 08 02 a6 mflr r0
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
ffc0ca60: 3d 20 00 00 lis r9,0
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
ffc0ca64: 90 01 00 14 stw r0,20(r1)
ffc0ca68: 93 e1 00 0c stw r31,12(r1)
ffc0ca6c: 7c 7f 1b 78 mr r31,r3
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
ffc0ca70: 81 29 31 30 lwz r9,12592(r9)
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0ca74: 7d 60 00 a6 mfmsr r11
ffc0ca78: 7c 10 42 a6 mfsprg r0,0
ffc0ca7c: 7d 60 00 78 andc r0,r11,r0
ffc0ca80: 7c 00 01 24 mtmsr r0
* If locked for reading and no waiters, then OK to read.
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
ffc0ca84: 80 03 00 44 lwz r0,68(r3)
ffc0ca88: 2f 80 00 00 cmpwi cr7,r0,0
ffc0ca8c: 41 9e 00 cc beq- cr7,ffc0cb58 <_CORE_RWLock_Release+0x100>
_ISR_Enable( level );
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
return CORE_RWLOCK_SUCCESSFUL;
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
ffc0ca90: 2f 80 00 01 cmpwi cr7,r0,1
ffc0ca94: 41 9e 00 94 beq- cr7,ffc0cb28 <_CORE_RWLock_Release+0xd0>
return CORE_RWLOCK_SUCCESSFUL;
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
ffc0ca98: 38 00 00 00 li r0,0
ffc0ca9c: 90 09 00 34 stw r0,52(r9)
/*
* Implicitly transition to "unlocked" and find another thread interested
* in obtaining this rwlock.
*/
the_rwlock->current_state = CORE_RWLOCK_UNLOCKED;
ffc0caa0: 90 1f 00 44 stw r0,68(r31)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0caa4: 7d 60 01 24 mtmsr r11
_ISR_Enable( level );
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
ffc0caa8: 7f e3 fb 78 mr r3,r31
ffc0caac: 48 00 23 b9 bl ffc0ee64 <_Thread_queue_Dequeue>
if ( next ) {
ffc0cab0: 2c 03 00 00 cmpwi r3,0
ffc0cab4: 41 82 00 5c beq- ffc0cb10 <_CORE_RWLock_Release+0xb8>
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
ffc0cab8: 80 03 00 30 lwz r0,48(r3)
ffc0cabc: 2f 80 00 01 cmpwi cr7,r0,1
ffc0cac0: 41 9e 00 bc beq- cr7,ffc0cb7c <_CORE_RWLock_Release+0x124>
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
ffc0cac4: 81 3f 00 48 lwz r9,72(r31)
ffc0cac8: 38 09 00 01 addi r0,r9,1
ffc0cacc: 90 1f 00 48 stw r0,72(r31)
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
ffc0cad0: 38 00 00 01 li r0,1
ffc0cad4: 90 1f 00 44 stw r0,68(r31)
ffc0cad8: 48 00 00 20 b ffc0caf8 <_CORE_RWLock_Release+0xa0>
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
if ( !next ||
ffc0cadc: 80 09 00 30 lwz r0,48(r9)
ffc0cae0: 2f 80 00 01 cmpwi cr7,r0,1
ffc0cae4: 41 9e 00 2c beq- cr7,ffc0cb10 <_CORE_RWLock_Release+0xb8><== NEVER TAKEN
next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE )
return CORE_RWLOCK_SUCCESSFUL;
the_rwlock->number_of_readers += 1;
ffc0cae8: 81 3f 00 48 lwz r9,72(r31)
ffc0caec: 38 09 00 01 addi r0,r9,1
ffc0caf0: 90 1f 00 48 stw r0,72(r31)
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
ffc0caf4: 48 00 28 11 bl ffc0f304 <_Thread_queue_Extract>
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
ffc0caf8: 7f e3 fb 78 mr r3,r31
ffc0cafc: 48 00 29 91 bl ffc0f48c <_Thread_queue_First>
if ( !next ||
ffc0cb00: 7c 69 1b 79 mr. r9,r3
next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE )
return CORE_RWLOCK_SUCCESSFUL;
the_rwlock->number_of_readers += 1;
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
ffc0cb04: 7f e3 fb 78 mr r3,r31
ffc0cb08: 7d 24 4b 78 mr r4,r9
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
if ( !next ||
ffc0cb0c: 40 82 ff d0 bne+ ffc0cadc <_CORE_RWLock_Release+0x84>
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
ffc0cb10: 80 01 00 14 lwz r0,20(r1)
ffc0cb14: 38 60 00 00 li r3,0
ffc0cb18: 83 e1 00 0c lwz r31,12(r1)
ffc0cb1c: 38 21 00 10 addi r1,r1,16
ffc0cb20: 7c 08 03 a6 mtlr r0
ffc0cb24: 4e 80 00 20 blr
_ISR_Enable( level );
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
return CORE_RWLOCK_SUCCESSFUL;
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
the_rwlock->number_of_readers -= 1;
ffc0cb28: 81 43 00 48 lwz r10,72(r3)
ffc0cb2c: 38 0a ff ff addi r0,r10,-1
if ( the_rwlock->number_of_readers != 0 ) {
ffc0cb30: 2f 80 00 00 cmpwi cr7,r0,0
_ISR_Enable( level );
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
return CORE_RWLOCK_SUCCESSFUL;
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
the_rwlock->number_of_readers -= 1;
ffc0cb34: 90 03 00 48 stw r0,72(r3)
if ( the_rwlock->number_of_readers != 0 ) {
ffc0cb38: 41 9e ff 60 beq+ cr7,ffc0ca98 <_CORE_RWLock_Release+0x40>
ffc0cb3c: 7d 60 01 24 mtmsr r11
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
ffc0cb40: 80 01 00 14 lwz r0,20(r1)
ffc0cb44: 38 60 00 00 li r3,0
ffc0cb48: 83 e1 00 0c lwz r31,12(r1)
ffc0cb4c: 38 21 00 10 addi r1,r1,16
ffc0cb50: 7c 08 03 a6 mtlr r0
ffc0cb54: 4e 80 00 20 blr
ffc0cb58: 7d 60 01 24 mtmsr r11
*/
_ISR_Disable( level );
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
_ISR_Enable( level );
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
ffc0cb5c: 38 00 00 02 li r0,2
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
ffc0cb60: 83 e1 00 0c lwz r31,12(r1)
*/
_ISR_Disable( level );
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
_ISR_Enable( level );
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
ffc0cb64: 90 09 00 34 stw r0,52(r9)
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
ffc0cb68: 38 60 00 00 li r3,0
ffc0cb6c: 80 01 00 14 lwz r0,20(r1)
ffc0cb70: 38 21 00 10 addi r1,r1,16
ffc0cb74: 7c 08 03 a6 mtlr r0
ffc0cb78: 4e 80 00 20 blr
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
if ( next ) {
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
ffc0cb7c: 38 00 00 02 li r0,2
ffc0cb80: 90 1f 00 44 stw r0,68(r31)
return CORE_RWLOCK_SUCCESSFUL;
ffc0cb84: 4b ff ff 8c b ffc0cb10 <_CORE_RWLock_Release+0xb8>
ffc0cb88 <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
ffc0cb88: 94 21 ff e8 stwu r1,-24(r1)
ffc0cb8c: 7c 08 02 a6 mflr r0
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
ffc0cb90: 38 81 00 08 addi r4,r1,8
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
ffc0cb94: 90 01 00 1c stw r0,28(r1)
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
ffc0cb98: 48 00 1e c9 bl ffc0ea60 <_Thread_Get>
switch ( location ) {
ffc0cb9c: 80 01 00 08 lwz r0,8(r1)
ffc0cba0: 2f 80 00 00 cmpwi cr7,r0,0
ffc0cba4: 40 9e 00 1c bne- cr7,ffc0cbc0 <_CORE_RWLock_Timeout+0x38><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
ffc0cba8: 48 00 2a 25 bl ffc0f5cc <_Thread_queue_Process_timeout>
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
ffc0cbac: 3d 20 00 00 lis r9,0
ffc0cbb0: 81 69 28 34 lwz r11,10292(r9)
ffc0cbb4: 38 0b ff ff addi r0,r11,-1
ffc0cbb8: 90 09 28 34 stw r0,10292(r9)
return _Thread_Dispatch_disable_level;
ffc0cbbc: 80 09 28 34 lwz r0,10292(r9)
_Thread_Unnest_dispatch();
break;
}
}
ffc0cbc0: 80 01 00 1c lwz r0,28(r1)
ffc0cbc4: 38 21 00 18 addi r1,r1,24
ffc0cbc8: 7c 08 03 a6 mtlr r0
ffc0cbcc: 4e 80 00 20 blr
ffc14fd4 <_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
)
{
ffc14fd4: 94 21 ff e0 stwu r1,-32(r1)
ffc14fd8: 7c 08 02 a6 mflr r0
ffc14fdc: 90 01 00 24 stw r0,36(r1)
/*
* 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)) {
ffc14fe0: 70 c0 00 03 andi. r0,r6,3
{
size_t message_buffering_required = 0;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
the_message_queue->number_of_pending_messages = 0;
ffc14fe4: 38 00 00 00 li r0,0
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
)
{
ffc14fe8: 93 81 00 10 stw r28,16(r1)
/*
* 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)) {
ffc14fec: 7c dc 33 78 mr r28,r6
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
)
{
ffc14ff0: 93 a1 00 14 stw r29,20(r1)
ffc14ff4: 7c 9d 23 78 mr r29,r4
ffc14ff8: 93 e1 00 1c stw r31,28(r1)
ffc14ffc: 7c 7f 1b 78 mr r31,r3
ffc15000: 93 c1 00 18 stw r30,24(r1)
size_t message_buffering_required = 0;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
ffc15004: 90 a3 00 44 stw r5,68(r3)
the_message_queue->number_of_pending_messages = 0;
ffc15008: 90 03 00 48 stw r0,72(r3)
the_message_queue->maximum_message_size = maximum_message_size;
ffc1500c: 90 c3 00 4c stw r6,76(r3)
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Notify_Handler the_handler,
void *the_argument
)
{
the_message_queue->notify_handler = the_handler;
ffc15010: 90 03 00 60 stw r0,96(r3)
the_message_queue->notify_argument = the_argument;
ffc15014: 90 03 00 64 stw r0,100(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)) {
ffc15018: 41 82 00 3c beq- ffc15054 <_CORE_message_queue_Initialize+0x80>
allocated_message_size += sizeof(uint32_t);
ffc1501c: 3b 86 00 04 addi r28,r6,4
allocated_message_size &= ~(sizeof(uint32_t) - 1);
ffc15020: 57 9c 00 3a rlwinm r28,r28,0,0,29
}
if (allocated_message_size < maximum_message_size)
ffc15024: 7f 86 e0 40 cmplw cr7,r6,r28
return false;
ffc15028: 3b c0 00 00 li r30,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)
ffc1502c: 40 9d 00 28 ble- cr7,ffc15054 <_CORE_message_queue_Initialize+0x80><== ALWAYS TAKEN
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
}
ffc15030: 80 01 00 24 lwz r0,36(r1)
ffc15034: 7f c3 f3 78 mr r3,r30
ffc15038: 83 81 00 10 lwz r28,16(r1)
ffc1503c: 7c 08 03 a6 mtlr r0
ffc15040: 83 a1 00 14 lwz r29,20(r1)
ffc15044: 83 c1 00 18 lwz r30,24(r1)
ffc15048: 83 e1 00 1c lwz r31,28(r1)
ffc1504c: 38 21 00 20 addi r1,r1,32
ffc15050: 4e 80 00 20 blr
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
if ( !size_t_mult32_with_overflow(
ffc15054: 3b 9c 00 14 addi r28,r28,20
size_t a,
size_t b,
size_t *c
)
{
long long x = (long long)a*b;
ffc15058: 7d 45 e0 16 mulhwu r10,r5,r28
ffc1505c: 7d 65 e1 d6 mullw r11,r5,r28
if ( x > SIZE_MAX )
ffc15060: 2f 8a 00 00 cmpwi cr7,r10,0
*/
if ( !size_t_mult32_with_overflow(
(size_t) maximum_pending_messages,
allocated_message_size + sizeof(CORE_message_queue_Buffer_control),
&message_buffering_required ) )
return false;
ffc15064: 3b c0 00 00 li r30,0
size_t *c
)
{
long long x = (long long)a*b;
if ( x > SIZE_MAX )
ffc15068: 41 bd ff c8 bgt- cr7,ffc15030 <_CORE_message_queue_Initialize+0x5c>
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
ffc1506c: 7d 63 5b 78 mr r3,r11
ffc15070: 90 a1 00 08 stw r5,8(r1)
ffc15074: 48 00 3e 15 bl ffc18e88 <_Workspace_Allocate>
if (the_message_queue->message_buffers == 0)
ffc15078: 2f 83 00 00 cmpwi cr7,r3,0
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
ffc1507c: 90 7f 00 5c stw r3,92(r31)
_Workspace_Allocate( message_buffering_required );
ffc15080: 7c 64 1b 78 mr r4,r3
if (the_message_queue->message_buffers == 0)
ffc15084: 80 a1 00 08 lwz r5,8(r1)
ffc15088: 41 be ff a8 beq- cr7,ffc15030 <_CORE_message_queue_Initialize+0x5c>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
ffc1508c: 38 7f 00 68 addi r3,r31,104
ffc15090: 7f 86 e3 78 mr r6,r28
ffc15094: 48 00 6e 5d bl ffc1bef0 <_Chain_Initialize>
allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
);
_Chain_Initialize_empty( &the_message_queue->Pending_messages );
_Thread_queue_Initialize(
ffc15098: 80 9d 00 00 lwz r4,0(r29)
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 );
ffc1509c: 38 1f 00 50 addi r0,r31,80
head->next = tail;
head->previous = NULL;
ffc150a0: 93 df 00 54 stw r30,84(r31)
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 );
ffc150a4: 39 3f 00 54 addi r9,r31,84
ffc150a8: 68 84 00 01 xori r4,r4,1
head->next = tail;
head->previous = NULL;
tail->previous = head;
ffc150ac: 90 1f 00 58 stw r0,88(r31)
ffc150b0: 7c 84 00 34 cntlzw r4,r4
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc150b4: 91 3f 00 50 stw r9,80(r31)
ffc150b8: 7f e3 fb 78 mr r3,r31
ffc150bc: 54 84 d9 7e rlwinm r4,r4,27,5,31
ffc150c0: 38 a0 00 80 li r5,128
ffc150c4: 38 c0 00 06 li r6,6
ffc150c8: 48 00 30 29 bl ffc180f0 <_Thread_queue_Initialize>
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
}
ffc150cc: 80 01 00 24 lwz r0,36(r1)
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
ffc150d0: 3b c0 00 01 li r30,1
}
ffc150d4: 83 81 00 10 lwz r28,16(r1)
ffc150d8: 7c 08 03 a6 mtlr r0
ffc150dc: 7f c3 f3 78 mr r3,r30
ffc150e0: 83 a1 00 14 lwz r29,20(r1)
ffc150e4: 83 c1 00 18 lwz r30,24(r1)
ffc150e8: 83 e1 00 1c lwz r31,28(r1)
ffc150ec: 38 21 00 20 addi r1,r1,32
ffc150f0: 4e 80 00 20 blr
ffc0a740 <_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
)
{
ffc0a740: 94 21 ff f0 stwu r1,-16(r1)
ffc0a744: 7c 08 02 a6 mflr r0
ffc0a748: 93 e1 00 0c stw r31,12(r1)
ffc0a74c: 7c 7f 1b 78 mr r31,r3
ffc0a750: 90 01 00 14 stw r0,20(r1)
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
ffc0a754: 48 00 21 d5 bl ffc0c928 <_Thread_queue_Dequeue>
ffc0a758: 2f 83 00 00 cmpwi cr7,r3,0
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
ffc0a75c: 38 60 00 00 li r3,0
if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
ffc0a760: 41 9e 00 18 beq- cr7,ffc0a778 <_CORE_semaphore_Surrender+0x38>
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
}
return status;
}
ffc0a764: 80 01 00 14 lwz r0,20(r1)
ffc0a768: 83 e1 00 0c lwz r31,12(r1)
ffc0a76c: 38 21 00 10 addi r1,r1,16
ffc0a770: 7c 08 03 a6 mtlr r0
ffc0a774: 4e 80 00 20 blr
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0a778: 7c 00 00 a6 mfmsr r0
ffc0a77c: 7d 30 42 a6 mfsprg r9,0
ffc0a780: 7c 09 48 78 andc r9,r0,r9
ffc0a784: 7d 20 01 24 mtmsr r9
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
ffc0a788: 81 3f 00 48 lwz r9,72(r31)
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
ffc0a78c: 38 60 00 04 li r3,4
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
ffc0a790: 81 7f 00 40 lwz r11,64(r31)
ffc0a794: 7f 89 58 40 cmplw cr7,r9,r11
ffc0a798: 40 9c 00 10 bge- cr7,ffc0a7a8 <_CORE_semaphore_Surrender+0x68><== NEVER TAKEN
the_semaphore->count += 1;
ffc0a79c: 39 29 00 01 addi r9,r9,1
ffc0a7a0: 91 3f 00 48 stw r9,72(r31)
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
ffc0a7a4: 38 60 00 00 li r3,0
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0a7a8: 7c 00 01 24 mtmsr r0
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
}
return status;
}
ffc0a7ac: 80 01 00 14 lwz r0,20(r1)
ffc0a7b0: 83 e1 00 0c lwz r31,12(r1)
ffc0a7b4: 38 21 00 10 addi r1,r1,16
ffc0a7b8: 7c 08 03 a6 mtlr r0
ffc0a7bc: 4e 80 00 20 blr
ffc10d48 <_Chain_Initialize>:
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
ffc10d48: 2c 05 00 00 cmpwi r5,0
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
ffc10d4c: 38 00 00 00 li r0,0
size_t node_size
)
{
size_t count = number_nodes;
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
ffc10d50: 39 43 00 04 addi r10,r3,4
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
ffc10d54: 90 03 00 04 stw r0,4(r3)
)
{
size_t count = number_nodes;
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *current = head;
ffc10d58: 7c 69 1b 78 mr r9,r3
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
ffc10d5c: 41 82 00 38 beq- ffc10d94 <_Chain_Initialize+0x4c> <== NEVER TAKEN
ffc10d60: 39 05 ff ff addi r8,r5,-1
)
{
size_t count = number_nodes;
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *current = head;
ffc10d64: 7c a9 03 a6 mtctr r5
Chain_Node *next = starting_address;
ffc10d68: 7c 89 23 78 mr r9,r4
)
{
size_t count = number_nodes;
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *current = head;
ffc10d6c: 7c 6b 1b 78 mr r11,r3
ffc10d70: 48 00 00 0c b ffc10d7c <_Chain_Initialize+0x34>
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
ffc10d74: 7d 2b 4b 78 mr r11,r9
current->next = next;
next->previous = current;
current = next;
next = (Chain_Node *)
ffc10d78: 7c 09 03 78 mr r9,r0
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
current->next = next;
ffc10d7c: 91 2b 00 00 stw r9,0(r11)
* node_size - size of node in bytes
*
* Output parameters: NONE
*/
void _Chain_Initialize(
ffc10d80: 7c 09 32 14 add r0,r9,r6
head->previous = NULL;
while ( count-- ) {
current->next = next;
next->previous = current;
ffc10d84: 91 69 00 04 stw r11,4(r9)
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
ffc10d88: 42 00 ff ec bdnz+ ffc10d74 <_Chain_Initialize+0x2c>
* node_size - size of node in bytes
*
* Output parameters: NONE
*/
void _Chain_Initialize(
ffc10d8c: 7c c6 41 d6 mullw r6,r6,r8
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
ffc10d90: 7d 24 32 14 add r9,r4,r6
current = next;
next = (Chain_Node *)
_Addresses_Add_offset( (void *) next, node_size );
}
current->next = tail;
ffc10d94: 91 49 00 00 stw r10,0(r9)
tail->previous = current;
ffc10d98: 91 23 00 08 stw r9,8(r3)
}
ffc10d9c: 4e 80 00 20 blr
ffc08f08 <_Event_Surrender>:
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
ffc08f08: 94 21 ff f0 stwu r1,-16(r1)
ffc08f0c: 7c 08 02 a6 mflr r0
ffc08f10: 90 01 00 14 stw r0,20(r1)
ffc08f14: 93 e1 00 0c stw r31,12(r1)
ffc08f18: 7c 7f 1b 78 mr r31,r3
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 ];
ffc08f1c: 81 63 01 30 lwz r11,304(r3)
option_set = (rtems_option) the_thread->Wait.option;
ffc08f20: 80 c3 00 30 lwz r6,48(r3)
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc08f24: 7d 40 00 a6 mfmsr r10
ffc08f28: 7c 10 42 a6 mfsprg r0,0
ffc08f2c: 7d 40 00 78 andc r0,r10,r0
ffc08f30: 7c 00 01 24 mtmsr r0
_ISR_Disable( level );
pending_events = api->pending_events;
ffc08f34: 81 2b 00 00 lwz r9,0(r11)
event_condition = (rtems_event_set) the_thread->Wait.count;
ffc08f38: 80 03 00 24 lwz r0,36(r3)
seized_events = _Event_sets_Get( pending_events, event_condition );
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
ffc08f3c: 7c 08 48 39 and. r8,r0,r9
ffc08f40: 41 82 00 e4 beq- ffc09024 <_Event_Surrender+0x11c>
/*
* 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() &&
ffc08f44: 3c e0 00 00 lis r7,0
ffc08f48: 38 e7 31 44 addi r7,r7,12612
ffc08f4c: 80 a7 00 08 lwz r5,8(r7)
ffc08f50: 2f 85 00 00 cmpwi cr7,r5,0
ffc08f54: 41 9e 00 10 beq- cr7,ffc08f64 <_Event_Surrender+0x5c>
ffc08f58: 80 e7 00 0c lwz r7,12(r7)
ffc08f5c: 7f 83 38 00 cmpw cr7,r3,r7
ffc08f60: 41 9e 00 78 beq- cr7,ffc08fd8 <_Event_Surrender+0xd0>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_for_event (
States_Control the_states
)
{
return (the_states & STATES_WAITING_FOR_EVENT);
ffc08f64: 80 ff 00 10 lwz r7,16(r31)
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
ffc08f68: 70 e5 01 00 andi. r5,r7,256
ffc08f6c: 41 82 00 b8 beq- ffc09024 <_Event_Surrender+0x11c>
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
ffc08f70: 7f 80 40 00 cmpw cr7,r0,r8
ffc08f74: 41 9e 00 0c beq- cr7,ffc08f80 <_Event_Surrender+0x78>
ffc08f78: 70 c0 00 02 andi. r0,r6,2
ffc08f7c: 41 82 00 a8 beq- ffc09024 <_Event_Surrender+0x11c> <== NEVER TAKEN
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;
ffc08f80: 80 ff 00 28 lwz r7,40(r31)
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) );
ffc08f84: 7d 29 40 78 andc r9,r9,r8
* 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 );
the_thread->Wait.count = 0;
ffc08f88: 38 00 00 00 li r0,0
/*
* 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 );
ffc08f8c: 91 2b 00 00 stw r9,0(r11)
the_thread->Wait.count = 0;
ffc08f90: 90 1f 00 24 stw r0,36(r31)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
ffc08f94: 91 07 00 00 stw r8,0(r7)
static inline void ppc_interrupt_flash( uint32_t level )
{
uint32_t current_level;
__asm__ volatile (
ffc08f98: 7c 00 00 a6 mfmsr r0
ffc08f9c: 7d 40 01 24 mtmsr r10
ffc08fa0: 7c 00 01 24 mtmsr r0
_ISR_Flash( level );
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
ffc08fa4: 80 1f 00 50 lwz r0,80(r31)
ffc08fa8: 2f 80 00 02 cmpwi cr7,r0,2
ffc08fac: 41 9e 00 90 beq- cr7,ffc0903c <_Event_Surrender+0x134>
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc08fb0: 7d 40 01 24 mtmsr r10
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
ffc08fb4: 3c 80 10 03 lis r4,4099
ffc08fb8: 7f e3 fb 78 mr r3,r31
ffc08fbc: 60 84 ff f8 ori r4,r4,65528
ffc08fc0: 48 00 30 a1 bl ffc0c060 <_Thread_Clear_state>
}
return;
}
}
_ISR_Enable( level );
}
ffc08fc4: 80 01 00 14 lwz r0,20(r1)
ffc08fc8: 83 e1 00 0c lwz r31,12(r1)
ffc08fcc: 38 21 00 10 addi r1,r1,16
ffc08fd0: 7c 08 03 a6 mtlr r0
ffc08fd4: 4e 80 00 20 blr
* 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) ||
ffc08fd8: 3c e0 00 00 lis r7,0
ffc08fdc: 80 a7 28 54 lwz r5,10324(r7)
/*
* 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 ) &&
ffc08fe0: 2f 85 00 02 cmpwi cr7,r5,2
ffc08fe4: 41 9e 00 10 beq- cr7,ffc08ff4 <_Event_Surrender+0xec> <== NEVER TAKEN
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
ffc08fe8: 80 a7 28 54 lwz r5,10324(r7)
* 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) ||
ffc08fec: 2f 85 00 01 cmpwi cr7,r5,1
ffc08ff0: 40 9e ff 74 bne+ cr7,ffc08f64 <_Event_Surrender+0x5c>
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
ffc08ff4: 7f 80 40 00 cmpw cr7,r0,r8
ffc08ff8: 41 9e 00 0c beq- cr7,ffc09004 <_Event_Surrender+0xfc>
ffc08ffc: 70 c0 00 02 andi. r0,r6,2
ffc09000: 41 82 00 24 beq- ffc09024 <_Event_Surrender+0x11c> <== NEVER TAKEN
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;
ffc09004: 80 df 00 28 lwz r6,40(r31)
_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 );
the_thread->Wait.count = 0;
ffc09008: 38 00 00 00 li r0,0
ffc0900c: 7d 29 40 78 andc r9,r9,r8
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 );
ffc09010: 91 2b 00 00 stw r9,0(r11)
the_thread->Wait.count = 0;
ffc09014: 90 1f 00 24 stw r0,36(r31)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
ffc09018: 38 00 00 03 li r0,3
((_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 );
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
ffc0901c: 91 06 00 00 stw r8,0(r6)
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
ffc09020: 90 07 28 54 stw r0,10324(r7)
ffc09024: 7d 40 01 24 mtmsr r10
}
return;
}
}
_ISR_Enable( level );
}
ffc09028: 80 01 00 14 lwz r0,20(r1)
ffc0902c: 83 e1 00 0c lwz r31,12(r1)
ffc09030: 38 21 00 10 addi r1,r1,16
ffc09034: 7c 08 03 a6 mtlr r0
ffc09038: 4e 80 00 20 blr
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
ffc0903c: 38 00 00 03 li r0,3
ffc09040: 90 1f 00 50 stw r0,80(r31)
ffc09044: 7d 40 01 24 mtmsr r10
_ISR_Enable( level );
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
ffc09048: 38 7f 00 48 addi r3,r31,72
ffc0904c: 48 00 49 79 bl ffc0d9c4 <_Watchdog_Remove>
ffc09050: 3c 80 10 03 lis r4,4099
ffc09054: 7f e3 fb 78 mr r3,r31
ffc09058: 60 84 ff f8 ori r4,r4,65528
ffc0905c: 48 00 30 05 bl ffc0c060 <_Thread_Clear_state>
ffc09060: 4b ff ff c8 b ffc09028 <_Event_Surrender+0x120>
ffc09064 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
ffc09064: 94 21 ff e8 stwu r1,-24(r1)
ffc09068: 7c 08 02 a6 mflr r0
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
ffc0906c: 38 81 00 08 addi r4,r1,8
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
ffc09070: 90 01 00 1c stw r0,28(r1)
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
ffc09074: 48 00 34 b1 bl ffc0c524 <_Thread_Get>
switch ( location ) {
ffc09078: 80 01 00 08 lwz r0,8(r1)
ffc0907c: 2f 80 00 00 cmpwi cr7,r0,0
ffc09080: 40 9e 00 54 bne- cr7,ffc090d4 <_Event_Timeout+0x70> <== NEVER TAKEN
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc09084: 7d 20 00 a6 mfmsr r9
ffc09088: 7d 70 42 a6 mfsprg r11,0
ffc0908c: 7d 2b 58 78 andc r11,r9,r11
ffc09090: 7d 60 01 24 mtmsr r11
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
ffc09094: 3d 60 00 00 lis r11,0
return;
}
#endif
the_thread->Wait.count = 0;
if ( _Thread_Is_executing( the_thread ) ) {
ffc09098: 81 6b 31 50 lwz r11,12624(r11)
_ISR_Enable( level );
return;
}
#endif
the_thread->Wait.count = 0;
ffc0909c: 90 03 00 24 stw r0,36(r3)
if ( _Thread_Is_executing( the_thread ) ) {
ffc090a0: 7f 83 58 00 cmpw cr7,r3,r11
ffc090a4: 41 9e 00 40 beq- cr7,ffc090e4 <_Event_Timeout+0x80>
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
ffc090a8: 38 00 00 06 li r0,6
ffc090ac: 90 03 00 34 stw r0,52(r3)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc090b0: 7d 20 01 24 mtmsr r9
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
ffc090b4: 3c 80 10 03 lis r4,4099
ffc090b8: 60 84 ff f8 ori r4,r4,65528
ffc090bc: 48 00 2f a5 bl ffc0c060 <_Thread_Clear_state>
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
ffc090c0: 3d 20 00 00 lis r9,0
ffc090c4: 81 69 28 0c lwz r11,10252(r9)
ffc090c8: 38 0b ff ff addi r0,r11,-1
ffc090cc: 90 09 28 0c stw r0,10252(r9)
return _Thread_Dispatch_disable_level;
ffc090d0: 80 09 28 0c lwz r0,10252(r9)
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
ffc090d4: 80 01 00 1c lwz r0,28(r1)
ffc090d8: 38 21 00 18 addi r1,r1,24
ffc090dc: 7c 08 03 a6 mtlr r0
ffc090e0: 4e 80 00 20 blr
}
#endif
the_thread->Wait.count = 0;
if ( _Thread_Is_executing( the_thread ) ) {
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
ffc090e4: 3d 60 00 00 lis r11,0
ffc090e8: 80 0b 28 54 lwz r0,10324(r11)
ffc090ec: 2f 80 00 01 cmpwi cr7,r0,1
ffc090f0: 40 9e ff b8 bne+ cr7,ffc090a8 <_Event_Timeout+0x44>
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
ffc090f4: 38 00 00 02 li r0,2
ffc090f8: 90 0b 28 54 stw r0,10324(r11)
ffc090fc: 4b ff ff ac b ffc090a8 <_Event_Timeout+0x44>
ffc10f94 <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
ffc10f94: 94 21 ff e0 stwu r1,-32(r1)
ffc10f98: 7c 08 02 a6 mflr r0
ffc10f9c: 7d 80 00 26 mfcr r12
ffc10fa0: 7c 89 23 78 mr r9,r4
ffc10fa4: 90 01 00 24 stw r0,36(r1)
Heap_Statistics *const stats = &heap->stats;
uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
ffc10fa8: 38 04 00 04 addi r0,r4,4
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
ffc10fac: 7f 84 00 40 cmplw cr7,r4,r0
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
ffc10fb0: 93 a1 00 14 stw r29,20(r1)
ffc10fb4: 7c 7d 1b 78 mr r29,r3
Heap_Statistics *const stats = &heap->stats;
uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
- HEAP_ALLOC_BONUS;
uintptr_t const page_size = heap->page_size;
ffc10fb8: 80 e3 00 10 lwz r7,16(r3)
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
/* Integer overflow occured */
return NULL;
ffc10fbc: 38 60 00 00 li r3,0
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
ffc10fc0: 93 61 00 0c stw r27,12(r1)
ffc10fc4: 93 81 00 10 stw r28,16(r1)
ffc10fc8: 93 c1 00 18 stw r30,24(r1)
ffc10fcc: 93 e1 00 1c stw r31,28(r1)
ffc10fd0: 91 81 00 08 stw r12,8(r1)
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
ffc10fd4: 41 9d 00 7c bgt- cr7,ffc11050 <_Heap_Allocate_aligned_with_boundary+0xbc>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
ffc10fd8: 2e 06 00 00 cmpwi cr4,r6,0
ffc10fdc: 40 92 01 b8 bne- cr4,ffc11194 <_Heap_Allocate_aligned_with_boundary+0x200>
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
ffc10fe0: 80 9d 00 08 lwz r4,8(r29)
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
ffc10fe4: 7f 9d 20 00 cmpw cr7,r29,r4
ffc10fe8: 41 9e 01 c4 beq- cr7,ffc111ac <_Heap_Allocate_aligned_with_boundary+0x218>
* The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag
* field. Thus the value is about one unit larger than the real block
* size. The greater than operator takes this into account.
*/
if ( block->size_and_flag > block_size_floor ) {
if ( alignment == 0 ) {
ffc10fec: 2c 05 00 00 cmpwi r5,0
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
ffc10ff0: 3b c0 00 00 li r30,0
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
ffc10ff4: 3b 67 00 07 addi r27,r7,7
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
ffc10ff8: 23 89 00 04 subfic r28,r9,4
ffc10ffc: 48 00 00 24 b ffc11020 <_Heap_Allocate_aligned_with_boundary+0x8c>
* The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag
* field. Thus the value is about one unit larger than the real block
* size. The greater than operator takes this into account.
*/
if ( block->size_and_flag > block_size_floor ) {
if ( alignment == 0 ) {
ffc11000: 40 82 00 7c bne- ffc1107c <_Heap_Allocate_aligned_with_boundary+0xe8>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
ffc11004: 3b e4 00 08 addi r31,r4,8
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
ffc11008: 2f 9f 00 00 cmpwi cr7,r31,0
);
}
}
/* Statistics */
++search_count;
ffc1100c: 3b de 00 01 addi r30,r30,1
if ( alloc_begin != 0 ) {
ffc11010: 40 9e 01 3c bne- cr7,ffc1114c <_Heap_Allocate_aligned_with_boundary+0x1b8>
break;
}
block = block->next;
ffc11014: 80 84 00 08 lwz r4,8(r4)
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
ffc11018: 7f 9d 20 00 cmpw cr7,r29,r4
ffc1101c: 41 9e 00 20 beq- cr7,ffc1103c <_Heap_Allocate_aligned_with_boundary+0xa8>
/*
* The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag
* field. Thus the value is about one unit larger than the real block
* size. The greater than operator takes this into account.
*/
if ( block->size_and_flag > block_size_floor ) {
ffc11020: 81 64 00 04 lwz r11,4(r4)
ffc11024: 7f 80 58 40 cmplw cr7,r0,r11
ffc11028: 41 bc ff d8 blt- cr7,ffc11000 <_Heap_Allocate_aligned_with_boundary+0x6c>
if ( alloc_begin != 0 ) {
break;
}
block = block->next;
ffc1102c: 80 84 00 08 lwz r4,8(r4)
);
}
}
/* Statistics */
++search_count;
ffc11030: 3b de 00 01 addi r30,r30,1
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
ffc11034: 7f 9d 20 00 cmpw cr7,r29,r4
ffc11038: 40 9e ff e8 bne+ cr7,ffc11020 <_Heap_Allocate_aligned_with_boundary+0x8c>
ffc1103c: 3b e0 00 00 li r31,0
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
ffc11040: 80 1d 00 44 lwz r0,68(r29)
ffc11044: 7f 80 f0 40 cmplw cr7,r0,r30
ffc11048: 41 9c 01 38 blt- cr7,ffc11180 <_Heap_Allocate_aligned_with_boundary+0x1ec>
stats->max_search = search_count;
}
return (void *) alloc_begin;
ffc1104c: 7f e3 fb 78 mr r3,r31
}
ffc11050: 80 01 00 24 lwz r0,36(r1)
ffc11054: 81 81 00 08 lwz r12,8(r1)
ffc11058: 7c 08 03 a6 mtlr r0
ffc1105c: 83 61 00 0c lwz r27,12(r1)
ffc11060: 83 81 00 10 lwz r28,16(r1)
ffc11064: 7d 80 81 20 mtcrf 8,r12
ffc11068: 83 a1 00 14 lwz r29,20(r1)
ffc1106c: 83 c1 00 18 lwz r30,24(r1)
ffc11070: 83 e1 00 1c lwz r31,28(r1)
ffc11074: 38 21 00 20 addi r1,r1,32
ffc11078: 4e 80 00 20 blr
- 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;
ffc1107c: 55 6b 00 3c rlwinm r11,r11,0,0,30
ffc11080: 80 7d 00 14 lwz r3,20(r29)
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
ffc11084: 7d 64 5a 14 add r11,r4,r11
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
uintptr_t alloc_begin = alloc_end - alloc_size;
ffc11088: 7f fc 5a 14 add r31,r28,r11
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
ffc1108c: 7f ff 2b 96 divwu r31,r31,r5
ffc11090: 7f ff 29 d6 mullw r31,r31,r5
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
ffc11094: 7d 43 d8 50 subf r10,r3,r27
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
ffc11098: 7d 6a 5a 14 add r11,r10,r11
uintptr_t alloc_begin = alloc_end - alloc_size;
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
/* Ensure that the we have a valid new block at the end */
if ( alloc_begin > alloc_begin_ceiling ) {
ffc1109c: 7f 8b f8 40 cmplw cr7,r11,r31
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
ffc110a0: 39 84 00 08 addi r12,r4,8
ffc110a4: 40 9c 00 0c bge- cr7,ffc110b0 <_Heap_Allocate_aligned_with_boundary+0x11c>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
ffc110a8: 7d 6b 2b 96 divwu r11,r11,r5
ffc110ac: 7f eb 29 d6 mullw r31,r11,r5
}
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
ffc110b0: 41 92 00 64 beq- cr4,ffc11114 <_Heap_Allocate_aligned_with_boundary+0x180>
/* Ensure that the we have a valid new block at the end */
if ( alloc_begin > alloc_begin_ceiling ) {
alloc_begin = _Heap_Align_down( alloc_begin_ceiling, alignment );
}
alloc_end = alloc_begin + alloc_size;
ffc110b4: 7d 5f 4a 14 add r10,r31,r9
ffc110b8: 7d 6a 33 96 divwu r11,r10,r6
ffc110bc: 7d 6b 31 d6 mullw r11,r11,r6
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
ffc110c0: 7f 9f 58 40 cmplw cr7,r31,r11
ffc110c4: 40 9c 00 50 bge- cr7,ffc11114 <_Heap_Allocate_aligned_with_boundary+0x180>
ffc110c8: 7f 8a 58 40 cmplw cr7,r10,r11
ffc110cc: 40 9d 00 48 ble- cr7,ffc11114 <_Heap_Allocate_aligned_with_boundary+0x180>
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
ffc110d0: 7d 0c 4a 14 add r8,r12,r9
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
if ( boundary_line < boundary_floor ) {
ffc110d4: 7f 88 58 40 cmplw cr7,r8,r11
return 0;
ffc110d8: 3b e0 00 00 li r31,0
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
if ( boundary_line < boundary_floor ) {
ffc110dc: 40 bd 00 10 ble+ cr7,ffc110ec <_Heap_Allocate_aligned_with_boundary+0x158>
ffc110e0: 4b ff ff 28 b ffc11008 <_Heap_Allocate_aligned_with_boundary+0x74>
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
ffc110e4: 40 99 00 30 ble- cr6,ffc11114 <_Heap_Allocate_aligned_with_boundary+0x180>
if ( boundary_line < boundary_floor ) {
ffc110e8: 41 85 00 a4 bgt- cr1,ffc1118c <_Heap_Allocate_aligned_with_boundary+0x1f8><== NEVER TAKEN
return 0;
}
alloc_begin = boundary_line - alloc_size;
ffc110ec: 7f e9 58 50 subf r31,r9,r11
ffc110f0: 7f ff 2b 96 divwu r31,r31,r5
ffc110f4: 7f ff 29 d6 mullw r31,r31,r5
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
alloc_end = alloc_begin + alloc_size;
ffc110f8: 7d 5f 4a 14 add r10,r31,r9
ffc110fc: 7d 6a 33 96 divwu r11,r10,r6
ffc11100: 7d 6b 31 d6 mullw r11,r11,r6
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
ffc11104: 7f 9f 58 40 cmplw cr7,r31,r11
ffc11108: 7f 0a 58 40 cmplw cr6,r10,r11
if ( boundary_line < boundary_floor ) {
ffc1110c: 7c 88 58 40 cmplw cr1,r8,r11
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
ffc11110: 41 9c ff d4 blt+ cr7,ffc110e4 <_Heap_Allocate_aligned_with_boundary+0x150>
boundary_line = _Heap_Align_down( alloc_end, boundary );
}
}
/* Ensure that the we have a valid new block at the beginning */
if ( alloc_begin >= alloc_begin_floor ) {
ffc11114: 7f 8c f8 40 cmplw cr7,r12,r31
ffc11118: 41 9d 00 74 bgt- cr7,ffc1118c <_Heap_Allocate_aligned_with_boundary+0x1f8>
ffc1111c: 7d 7f 3b 96 divwu r11,r31,r7
ffc11120: 7d 6b 39 d6 mullw r11,r11,r7
ffc11124: 21 44 ff f8 subfic r10,r4,-8
uintptr_t const alloc_block_begin =
(uintptr_t) _Heap_Block_of_alloc_area( alloc_begin, page_size );
uintptr_t const free_size = alloc_block_begin - block_begin;
ffc11128: 7d 6a 5a 14 add r11,r10,r11
if ( free_size >= min_block_size || free_size == 0 ) {
ffc1112c: 7f 83 58 40 cmplw cr7,r3,r11
ffc11130: 40 bd fe d8 ble- cr7,ffc11008 <_Heap_Allocate_aligned_with_boundary+0x74>
return alloc_begin;
}
}
return 0;
ffc11134: 31 6b ff ff addic r11,r11,-1
ffc11138: 7d 6b 59 10 subfe r11,r11,r11
ffc1113c: 7f ff 58 38 and r31,r31,r11
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
ffc11140: 2f 9f 00 00 cmpwi cr7,r31,0
);
}
}
/* Statistics */
++search_count;
ffc11144: 3b de 00 01 addi r30,r30,1
if ( alloc_begin != 0 ) {
ffc11148: 41 9e fe cc beq+ cr7,ffc11014 <_Heap_Allocate_aligned_with_boundary+0x80>
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
ffc1114c: 81 7d 00 48 lwz r11,72(r29)
stats->searches += search_count;
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
ffc11150: 7f a3 eb 78 mr r3,r29
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
stats->searches += search_count;
ffc11154: 80 1d 00 4c lwz r0,76(r29)
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
ffc11158: 7f e5 fb 78 mr r5,r31
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
ffc1115c: 39 6b 00 01 addi r11,r11,1
stats->searches += search_count;
ffc11160: 7c 00 f2 14 add r0,r0,r30
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
ffc11164: 91 7d 00 48 stw r11,72(r29)
stats->searches += search_count;
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
ffc11168: 7d 26 4b 78 mr r6,r9
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
stats->searches += search_count;
ffc1116c: 90 1d 00 4c stw r0,76(r29)
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
ffc11170: 4b ff 9a e5 bl ffc0ac54 <_Heap_Block_allocate>
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
ffc11174: 80 1d 00 44 lwz r0,68(r29)
ffc11178: 7f 80 f0 40 cmplw cr7,r0,r30
ffc1117c: 40 bc fe d0 bge- cr7,ffc1104c <_Heap_Allocate_aligned_with_boundary+0xb8>
stats->max_search = search_count;
ffc11180: 93 dd 00 44 stw r30,68(r29)
}
return (void *) alloc_begin;
ffc11184: 7f e3 fb 78 mr r3,r31
ffc11188: 4b ff fe c8 b ffc11050 <_Heap_Allocate_aligned_with_boundary+0xbc>
if ( free_size >= min_block_size || free_size == 0 ) {
return alloc_begin;
}
}
return 0;
ffc1118c: 3b e0 00 00 li r31,0
ffc11190: 4b ff fe 78 b ffc11008 <_Heap_Allocate_aligned_with_boundary+0x74>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
ffc11194: 7f 84 30 40 cmplw cr7,r4,r6
ffc11198: 41 bd fe b8 bgt- cr7,ffc11050 <_Heap_Allocate_aligned_with_boundary+0xbc>
return NULL;
}
if ( alignment == 0 ) {
ffc1119c: 2f 85 00 00 cmpwi cr7,r5,0
ffc111a0: 40 be fe 40 bne- cr7,ffc10fe0 <_Heap_Allocate_aligned_with_boundary+0x4c>
alignment = page_size;
ffc111a4: 7c e5 3b 78 mr r5,r7
ffc111a8: 4b ff fe 38 b ffc10fe0 <_Heap_Allocate_aligned_with_boundary+0x4c>
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
ffc111ac: 3b c0 00 00 li r30,0
ffc111b0: 3b e0 00 00 li r31,0
ffc111b4: 4b ff fe 8c b ffc11040 <_Heap_Allocate_aligned_with_boundary+0xac>
ffc10d94 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
ffc10d94: 94 21 ff c0 stwu r1,-64(r1)
ffc10d98: 7d 80 00 26 mfcr r12
ffc10d9c: 7c 08 02 a6 mflr r0
ffc10da0: 93 a1 00 34 stw r29,52(r1)
Heap_Block *extend_first_block = NULL;
Heap_Block *extend_last_block = NULL;
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;
ffc10da4: 7f a4 2a 14 add r29,r4,r5
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 ) {
ffc10da8: 7f 84 e8 40 cmplw cr7,r4,r29
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
ffc10dac: 90 01 00 44 stw r0,68(r1)
ffc10db0: 93 41 00 28 stw r26,40(r1)
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;
ffc10db4: 3b 40 00 00 li r26,0
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
ffc10db8: 93 c1 00 38 stw r30,56(r1)
ffc10dbc: 7c 7e 1b 78 mr r30,r3
ffc10dc0: 93 01 00 20 stw r24,32(r1)
ffc10dc4: 93 21 00 24 stw r25,36(r1)
ffc10dc8: 7c d9 33 78 mr r25,r6
ffc10dcc: 93 61 00 2c stw r27,44(r1)
ffc10dd0: 93 81 00 30 stw r28,48(r1)
ffc10dd4: 93 e1 00 3c stw r31,60(r1)
ffc10dd8: 7c 9f 23 78 mr r31,r4
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const first_block = heap->first_block;
ffc10ddc: 83 63 00 20 lwz r27,32(r3)
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;
ffc10de0: 38 60 00 00 li r3,0
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
ffc10de4: 92 e1 00 1c stw r23,28(r1)
ffc10de8: 91 81 00 18 stw r12,24(r1)
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;
ffc10dec: 93 41 00 0c stw r26,12(r1)
Heap_Block *extend_last_block = NULL;
ffc10df0: 93 41 00 08 stw r26,8(r1)
uintptr_t const page_size = heap->page_size;
ffc10df4: 83 9e 00 10 lwz r28,16(r30)
uintptr_t const min_block_size = heap->min_block_size;
ffc10df8: 80 de 00 14 lwz r6,20(r30)
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;
ffc10dfc: 83 1e 00 30 lwz r24,48(r30)
uintptr_t extend_first_block_size = 0;
uintptr_t extended_size = 0;
bool extend_area_ok = false;
if ( extend_area_end < extend_area_begin ) {
ffc10e00: 40 9d 00 40 ble- cr7,ffc10e40 <_Heap_Extend+0xac>
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
ffc10e04: 80 01 00 44 lwz r0,68(r1)
ffc10e08: 81 81 00 18 lwz r12,24(r1)
ffc10e0c: 7c 08 03 a6 mtlr r0
ffc10e10: 82 e1 00 1c lwz r23,28(r1)
ffc10e14: 83 01 00 20 lwz r24,32(r1)
ffc10e18: 7d 81 81 20 mtcrf 24,r12
ffc10e1c: 83 21 00 24 lwz r25,36(r1)
ffc10e20: 83 41 00 28 lwz r26,40(r1)
ffc10e24: 83 61 00 2c lwz r27,44(r1)
ffc10e28: 83 81 00 30 lwz r28,48(r1)
ffc10e2c: 83 a1 00 34 lwz r29,52(r1)
ffc10e30: 83 c1 00 38 lwz r30,56(r1)
ffc10e34: 83 e1 00 3c lwz r31,60(r1)
ffc10e38: 38 21 00 40 addi r1,r1,64
ffc10e3c: 4e 80 00 20 blr
if ( extend_area_end < extend_area_begin ) {
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
ffc10e40: 7c 83 23 78 mr r3,r4
ffc10e44: 38 e1 00 0c addi r7,r1,12
ffc10e48: 7c a4 2b 78 mr r4,r5
ffc10e4c: 39 01 00 08 addi r8,r1,8
ffc10e50: 7f 85 e3 78 mr r5,r28
ffc10e54: 4b ff 98 3d bl ffc0a690 <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
ffc10e58: 2f 83 00 00 cmpwi cr7,r3,0
/* For simplicity we reject extend areas that are too small */
return false;
ffc10e5c: 7f 43 d3 78 mr r3,r26
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
ffc10e60: 41 be ff a4 beq- cr7,ffc10e04 <_Heap_Extend+0x70>
ffc10e64: 7f 69 db 78 mr r9,r27
ffc10e68: 3a e0 00 00 li r23,0
ffc10e6c: 38 00 00 00 li r0,0
ffc10e70: 39 00 00 00 li r8,0
ffc10e74: 48 00 00 44 b ffc10eb8 <_Heap_Extend+0x124>
return false;
}
if ( extend_area_end == sub_area_begin ) {
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
ffc10e78: 7f 9d 58 40 cmplw cr7,r29,r11
ffc10e7c: 40 9c 00 08 bge- cr7,ffc10e84 <_Heap_Extend+0xf0>
ffc10e80: 7d 20 4b 78 mr r0,r9
ffc10e84: 7d 4b e3 96 divwu r10,r11,r28
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
ffc10e88: 7f 8b f8 00 cmpw cr7,r11,r31
ffc10e8c: 7d 4a e1 d6 mullw r10,r10,r28
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
ffc10e90: 39 4a ff f8 addi r10,r10,-8
ffc10e94: 41 9e 00 64 beq- cr7,ffc10ef8 <_Heap_Extend+0x164>
start_block->prev_size = extend_area_end;
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
ffc10e98: 7f 9f 58 40 cmplw cr7,r31,r11
ffc10e9c: 40 9d 00 08 ble- cr7,ffc10ea4 <_Heap_Extend+0x110>
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 )
ffc10ea0: 7d 57 53 78 mr r23,r10
- 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;
ffc10ea4: 81 2a 00 04 lwz r9,4(r10)
ffc10ea8: 55 29 00 3c rlwinm r9,r9,0,0,30
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
ffc10eac: 7d 29 52 14 add r9,r9,r10
link_above_block = end_block;
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
ffc10eb0: 7f 9b 48 00 cmpw cr7,r27,r9
ffc10eb4: 41 9e 00 60 beq- cr7,ffc10f14 <_Heap_Extend+0x180>
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
ffc10eb8: 7f 89 d8 00 cmpw cr7,r9,r27
ffc10ebc: 7d 2a 4b 78 mr r10,r9
ffc10ec0: 41 9e 01 b8 beq- cr7,ffc11078 <_Heap_Extend+0x2e4>
uintptr_t const sub_area_end = start_block->prev_size;
ffc10ec4: 81 69 00 00 lwz r11,0(r9)
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
ffc10ec8: 7f 9f 58 40 cmplw cr7,r31,r11
ffc10ecc: 40 9c 00 0c bge- cr7,ffc10ed8 <_Heap_Extend+0x144>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
ffc10ed0: 7f 8a e8 40 cmplw cr7,r10,r29
ffc10ed4: 41 9c 02 28 blt- cr7,ffc110fc <_Heap_Extend+0x368>
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
ffc10ed8: 7f 8a e8 00 cmpw cr7,r10,r29
ffc10edc: 40 9e ff 9c bne+ cr7,ffc10e78 <_Heap_Extend+0xe4>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
ffc10ee0: 7d 4b e3 96 divwu r10,r11,r28
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
ffc10ee4: 7f 8b f8 00 cmpw cr7,r11,r31
ffc10ee8: 7d 4a e1 d6 mullw r10,r10,r28
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
ffc10eec: 7d 28 4b 78 mr r8,r9
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
ffc10ef0: 39 4a ff f8 addi r10,r10,-8
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
ffc10ef4: 40 9e ff a4 bne+ cr7,ffc10e98 <_Heap_Extend+0x104> <== ALWAYS TAKEN
start_block->prev_size = extend_area_end;
ffc10ef8: 93 a9 00 00 stw r29,0(r9)
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 )
ffc10efc: 7d 5a 53 78 mr r26,r10
- 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;
ffc10f00: 81 2a 00 04 lwz r9,4(r10)
ffc10f04: 55 29 00 3c rlwinm r9,r9,0,0,30
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
ffc10f08: 7d 29 52 14 add r9,r9,r10
} else if ( sub_area_end < extend_area_begin ) {
link_above_block = end_block;
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
ffc10f0c: 7f 9b 48 00 cmpw cr7,r27,r9
ffc10f10: 40 9e ff a8 bne+ cr7,ffc10eb8 <_Heap_Extend+0x124> <== NEVER TAKEN
if ( extend_area_begin < heap->area_begin ) {
ffc10f14: 81 3e 00 18 lwz r9,24(r30)
ffc10f18: 7f 9f 48 40 cmplw cr7,r31,r9
ffc10f1c: 41 9c 01 64 blt- cr7,ffc11080 <_Heap_Extend+0x2ec>
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
ffc10f20: 81 3e 00 1c lwz r9,28(r30)
ffc10f24: 7f 9d 48 40 cmplw cr7,r29,r9
ffc10f28: 40 9d 00 08 ble- cr7,ffc10f30 <_Heap_Extend+0x19c>
heap->area_end = extend_area_end;
ffc10f2c: 93 be 00 1c stw r29,28(r30)
extend_last_block->prev_size = extend_first_block_size;
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 ) {
ffc10f30: 81 5e 00 20 lwz r10,32(r30)
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
ffc10f34: 81 21 00 0c lwz r9,12(r1)
ffc10f38: 81 61 00 08 lwz r11,8(r1)
extend_last_block->prev_size = extend_first_block_size;
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 ) {
ffc10f3c: 7f 8a 48 40 cmplw cr7,r10,r9
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
ffc10f40: 93 a9 00 00 stw r29,0(r9)
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
ffc10f44: 7d 49 58 50 subf r10,r9,r11
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
ffc10f48: 61 47 00 01 ori r7,r10,1
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
ffc10f4c: 91 4b 00 00 stw r10,0(r11)
extend_last_block->size_and_flag = 0;
ffc10f50: 39 40 00 00 li r10,0
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 =
ffc10f54: 90 e9 00 04 stw r7,4(r9)
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;
ffc10f58: 91 4b 00 04 stw r10,4(r11)
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
ffc10f5c: 40 9d 01 58 ble- cr7,ffc110b4 <_Heap_Extend+0x320> <== ALWAYS TAKEN
heap->first_block = extend_first_block;
ffc10f60: 91 3e 00 20 stw r9,32(r30)
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
heap->last_block = extend_last_block;
}
if ( merge_below_block != NULL ) {
ffc10f64: 2e 08 00 00 cmpwi cr4,r8,0
ffc10f68: 41 92 01 b0 beq- cr4,ffc11118 <_Heap_Extend+0x384>
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
ffc10f6c: 80 1e 00 10 lwz r0,16(r30)
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
ffc10f70: 3b ff 00 08 addi r31,r31,8
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
ffc10f74: 7d 3f 03 96 divwu r9,r31,r0
ffc10f78: 7d 29 01 d6 mullw r9,r9,r0
if ( remainder != 0 ) {
ffc10f7c: 7d 29 f8 51 subf. r9,r9,r31
ffc10f80: 41 82 00 0c beq- ffc10f8c <_Heap_Extend+0x1f8> <== NEVER TAKEN
return value - remainder + alignment;
ffc10f84: 7f ff 02 14 add r31,r31,r0
ffc10f88: 7f e9 f8 50 subf r31,r9,r31
uintptr_t const new_first_block_begin =
ffc10f8c: 38 9f ff f8 addi r4,r31,-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;
ffc10f90: 81 28 00 00 lwz r9,0(r8)
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 =
ffc10f94: 7c 04 40 50 subf r0,r4,r8
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;
ffc10f98: 60 00 00 01 ori r0,r0,1
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;
ffc10f9c: 91 3f ff f8 stw r9,-8(r31)
new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
_Heap_Free_block( heap, new_first_block );
ffc10fa0: 7f c3 f3 78 mr r3,r30
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;
new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
ffc10fa4: 90 04 00 04 stw r0,4(r4)
_Heap_Free_block( heap, new_first_block );
ffc10fa8: 4b ff fd b1 bl ffc10d58 <_Heap_Free_block>
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
ffc10fac: 2d 9a 00 00 cmpwi cr3,r26,0
ffc10fb0: 41 8e 01 18 beq- cr3,ffc110c8 <_Heap_Extend+0x334>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
ffc10fb4: 81 3e 00 10 lwz r9,16(r30)
)
{
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,
ffc10fb8: 38 1d ff f8 addi r0,r29,-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(
ffc10fbc: 7c 1a 00 50 subf r0,r26,r0
);
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)
ffc10fc0: 81 7a 00 04 lwz r11,4(r26)
ffc10fc4: 7c 00 4b 96 divwu r0,r0,r9
ffc10fc8: 7c 00 49 d6 mullw r0,r0,r9
| HEAP_PREV_BLOCK_USED;
_Heap_Block_set_size( last_block, last_block_new_size );
_Heap_Free_block( heap, last_block );
ffc10fcc: 7f c3 f3 78 mr r3,r30
);
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)
ffc10fd0: 7d 60 58 50 subf r11,r0,r11
page_size
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
ffc10fd4: 7d 20 d2 14 add r9,r0,r26
(last_block->size_and_flag - last_block_new_size)
| HEAP_PREV_BLOCK_USED;
ffc10fd8: 61 6b 00 01 ori r11,r11,1
page_size
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
ffc10fdc: 91 69 00 04 stw r11,4(r9)
(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 );
ffc10fe0: 7f 44 d3 78 mr r4,r26
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;
ffc10fe4: 81 3a 00 04 lwz r9,4(r26)
ffc10fe8: 55 29 07 fe clrlwi r9,r9,31
block->size_and_flag = size | flag;
ffc10fec: 7c 00 4b 78 or r0,r0,r9
ffc10ff0: 90 1a 00 04 stw r0,4(r26)
ffc10ff4: 4b ff fd 65 bl ffc10d58 <_Heap_Free_block>
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
ffc10ff8: 41 92 01 0c beq- cr4,ffc11104 <_Heap_Extend+0x370>
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
ffc10ffc: 81 3e 00 24 lwz r9,36(r30)
extended_size = stats->free_size - free_size;
/* Statistics */
stats->size += extended_size;
if ( extended_size_ptr != NULL )
ffc11000: 2f 99 00 00 cmpwi cr7,r25,0
* 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(
ffc11004: 81 7e 00 20 lwz r11,32(r30)
*extended_size_ptr = extended_size;
return true;
ffc11008: 38 60 00 01 li r3,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;
ffc1100c: 80 09 00 04 lwz r0,4(r9)
* 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(
ffc11010: 7d 69 58 50 subf r11,r9,r11
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;
ffc11014: 54 00 07 fe clrlwi r0,r0,31
block->size_and_flag = size | flag;
ffc11018: 7c 00 5b 78 or r0,r0,r11
ffc1101c: 90 09 00 04 stw r0,4(r9)
_Heap_Free_block( heap, extend_first_block );
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
ffc11020: 81 3e 00 30 lwz r9,48(r30)
/* Statistics */
stats->size += extended_size;
ffc11024: 80 1e 00 2c lwz r0,44(r30)
_Heap_Free_block( heap, extend_first_block );
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
ffc11028: 7f 18 48 50 subf r24,r24,r9
/* Statistics */
stats->size += extended_size;
ffc1102c: 7c 00 c2 14 add r0,r0,r24
ffc11030: 90 1e 00 2c stw r0,44(r30)
if ( extended_size_ptr != NULL )
ffc11034: 41 be fd d0 beq- cr7,ffc10e04 <_Heap_Extend+0x70> <== NEVER TAKEN
*extended_size_ptr = extended_size;
return true;
}
ffc11038: 80 01 00 44 lwz r0,68(r1)
ffc1103c: 81 81 00 18 lwz r12,24(r1)
ffc11040: 7c 08 03 a6 mtlr r0
/* Statistics */
stats->size += extended_size;
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
ffc11044: 93 19 00 00 stw r24,0(r25)
return true;
}
ffc11048: 7d 81 81 20 mtcrf 24,r12
ffc1104c: 82 e1 00 1c lwz r23,28(r1)
ffc11050: 83 01 00 20 lwz r24,32(r1)
ffc11054: 83 21 00 24 lwz r25,36(r1)
ffc11058: 83 41 00 28 lwz r26,40(r1)
ffc1105c: 83 61 00 2c lwz r27,44(r1)
ffc11060: 83 81 00 30 lwz r28,48(r1)
ffc11064: 83 a1 00 34 lwz r29,52(r1)
ffc11068: 83 c1 00 38 lwz r30,56(r1)
ffc1106c: 83 e1 00 3c lwz r31,60(r1)
ffc11070: 38 21 00 40 addi r1,r1,64
ffc11074: 4e 80 00 20 blr
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
ffc11078: 81 5e 00 18 lwz r10,24(r30)
ffc1107c: 4b ff fe 48 b ffc10ec4 <_Heap_Extend+0x130>
extend_last_block->prev_size = extend_first_block_size;
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 ) {
ffc11080: 81 5e 00 20 lwz r10,32(r30)
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
ffc11084: 81 21 00 0c lwz r9,12(r1)
ffc11088: 81 61 00 08 lwz r11,8(r1)
extend_last_block->prev_size = extend_first_block_size;
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 ) {
ffc1108c: 7f 8a 48 40 cmplw cr7,r10,r9
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
if ( extend_area_begin < heap->area_begin ) {
heap->area_begin = extend_area_begin;
ffc11090: 93 fe 00 18 stw r31,24(r30)
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
ffc11094: 7d 49 58 50 subf r10,r9,r11
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
ffc11098: 61 47 00 01 ori r7,r10,1
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
ffc1109c: 93 a9 00 00 stw r29,0(r9)
extend_first_block->size_and_flag =
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;
ffc110a0: 91 4b 00 00 stw r10,0(r11)
extend_last_block->size_and_flag = 0;
ffc110a4: 39 40 00 00 li r10,0
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 =
ffc110a8: 90 e9 00 04 stw r7,4(r9)
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;
ffc110ac: 91 4b 00 04 stw r10,4(r11)
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
ffc110b0: 41 bd fe b0 bgt- cr7,ffc10f60 <_Heap_Extend+0x1cc> <== ALWAYS TAKEN
heap->first_block = extend_first_block;
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
ffc110b4: 81 3e 00 24 lwz r9,36(r30)
ffc110b8: 7f 89 58 40 cmplw cr7,r9,r11
ffc110bc: 40 bc fe a8 bge- cr7,ffc10f64 <_Heap_Extend+0x1d0>
heap->last_block = extend_last_block;
ffc110c0: 91 7e 00 24 stw r11,36(r30)
ffc110c4: 4b ff fe a0 b ffc10f64 <_Heap_Extend+0x1d0>
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
ffc110c8: 2f 97 00 00 cmpwi cr7,r23,0
ffc110cc: 41 be ff 2c beq- cr7,ffc10ff8 <_Heap_Extend+0x264>
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;
ffc110d0: 81 37 00 04 lwz r9,4(r23)
)
{
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 );
ffc110d4: 80 01 00 0c lwz r0,12(r1)
ffc110d8: 55 29 07 fe clrlwi r9,r9,31
ffc110dc: 7c 17 00 50 subf r0,r23,r0
block->size_and_flag = size | flag;
ffc110e0: 7d 20 03 78 or r0,r9,r0
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
_Heap_Link_above(
ffc110e4: 81 21 00 08 lwz r9,8(r1)
ffc110e8: 90 17 00 04 stw r0,4(r23)
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 );
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
ffc110ec: 80 09 00 04 lwz r0,4(r9)
ffc110f0: 60 00 00 01 ori r0,r0,1
ffc110f4: 90 09 00 04 stw r0,4(r9)
ffc110f8: 4b ff ff 00 b ffc10ff8 <_Heap_Extend+0x264>
_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;
ffc110fc: 38 60 00 00 li r3,0
ffc11100: 4b ff fd 04 b ffc10e04 <_Heap_Extend+0x70>
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
ffc11104: 40 8e fe f8 bne+ cr3,ffc10ffc <_Heap_Extend+0x268>
_Heap_Free_block( heap, extend_first_block );
ffc11108: 80 81 00 0c lwz r4,12(r1)
ffc1110c: 7f c3 f3 78 mr r3,r30
ffc11110: 4b ff fc 49 bl ffc10d58 <_Heap_Free_block>
ffc11114: 4b ff fe e8 b ffc10ffc <_Heap_Extend+0x268>
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 ) {
ffc11118: 2f 80 00 00 cmpwi cr7,r0,0
ffc1111c: 41 be fe 90 beq- cr7,ffc10fac <_Heap_Extend+0x218>
{
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;
ffc11120: 7c 0b 00 50 subf r0,r11,r0
ffc11124: 60 00 00 01 ori r0,r0,1
)
{
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const link_begin = (uintptr_t) link;
last_block->size_and_flag =
ffc11128: 90 0b 00 04 stw r0,4(r11)
ffc1112c: 4b ff fe 80 b ffc10fac <_Heap_Extend+0x218>
ffc111b8 <_Heap_Free>:
/*
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
ffc111b8: 2c 04 00 00 cmpwi r4,0
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
ffc111bc: 94 21 ff f0 stwu r1,-16(r1)
ffc111c0: 7c 69 1b 78 mr r9,r3
ffc111c4: 93 e1 00 0c stw r31,12(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;
ffc111c8: 38 60 00 01 li r3,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 ) {
ffc111cc: 41 82 01 44 beq- ffc11310 <_Heap_Free+0x158>
ffc111d0: 80 09 00 10 lwz r0,16(r9)
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 ) ) {
return false;
ffc111d4: 38 60 00 00 li r3,0
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
ffc111d8: 81 69 00 20 lwz r11,32(r9)
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
ffc111dc: 7c 84 03 96 divwu r4,r4,r0
ffc111e0: 7c 84 01 d6 mullw r4,r4,r0
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
ffc111e4: 38 84 ff f8 addi r4,r4,-8
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;
ffc111e8: 7f 84 58 40 cmplw cr7,r4,r11
ffc111ec: 41 9c 01 24 blt- cr7,ffc11310 <_Heap_Free+0x158>
ffc111f0: 80 09 00 24 lwz r0,36(r9)
ffc111f4: 7f 84 00 40 cmplw cr7,r4,r0
ffc111f8: 41 9d 01 18 bgt- cr7,ffc11310 <_Heap_Free+0x158>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
ffc111fc: 81 04 00 04 lwz r8,4(r4)
- 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;
ffc11200: 55 07 00 3c rlwinm r7,r8,0,0,30
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
ffc11204: 7d 47 22 14 add r10,r7,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;
ffc11208: 7f 8b 50 40 cmplw cr7,r11,r10
ffc1120c: 41 9d 01 04 bgt- cr7,ffc11310 <_Heap_Free+0x158> <== NEVER TAKEN
ffc11210: 7f 80 50 40 cmplw cr7,r0,r10
ffc11214: 41 9c 00 fc blt- cr7,ffc11310 <_Heap_Free+0x158>
ffc11218: 80 ca 00 04 lwz r6,4(r10)
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
ffc1121c: 70 c5 00 01 andi. r5,r6,1
ffc11220: 41 82 00 f0 beq- ffc11310 <_Heap_Free+0x158>
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
ffc11224: 7f 80 50 00 cmpw cr7,r0,r10
- 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;
ffc11228: 54 c5 00 3c rlwinm r5,r6,0,0,30
ffc1122c: 38 c0 00 00 li r6,0
ffc11230: 41 9e 00 18 beq- cr7,ffc11248 <_Heap_Free+0x90>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
ffc11234: 7c ca 2a 14 add r6,r10,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;
ffc11238: 80 c6 00 04 lwz r6,4(r6)
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
ffc1123c: 70 c3 00 01 andi. r3,r6,1
ffc11240: 7c c0 00 26 mfcr r6
ffc11244: 54 c6 1f fe rlwinm r6,r6,3,31,31
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
if ( !_Heap_Is_prev_used( block ) ) {
ffc11248: 71 08 00 01 andi. r8,r8,1
ffc1124c: 40 82 00 6c bne- ffc112b8 <_Heap_Free+0x100>
uintptr_t const prev_size = block->prev_size;
ffc11250: 83 e4 00 00 lwz r31,0(r4)
Heap_Block * const prev_block = _Heap_Block_at( block, -prev_size );
if ( !_Heap_Is_block_in_heap( heap, prev_block ) ) {
_HAssert( false );
return( false );
ffc11254: 38 60 00 00 li r3,0
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
ffc11258: 7d 9f 20 50 subf r12,r31,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;
ffc1125c: 7f 8b 60 40 cmplw cr7,r11,r12
ffc11260: 41 9d 00 b0 bgt- cr7,ffc11310 <_Heap_Free+0x158> <== NEVER TAKEN
ffc11264: 7f 80 60 40 cmplw cr7,r0,r12
ffc11268: 7d 03 43 78 mr r3,r8
ffc1126c: 41 9c 00 a4 blt- cr7,ffc11310 <_Heap_Free+0x158> <== 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;
ffc11270: 80 0c 00 04 lwz r0,4(r12)
}
/* As we always coalesce free blocks, the block that preceedes prev_block
must have been used. */
if ( !_Heap_Is_prev_used ( prev_block) ) {
ffc11274: 70 0b 00 01 andi. r11,r0,1
ffc11278: 41 82 00 98 beq- ffc11310 <_Heap_Free+0x158> <== NEVER TAKEN
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
ffc1127c: 2f 86 00 00 cmpwi cr7,r6,0
ffc11280: 41 9e 00 e8 beq- cr7,ffc11368 <_Heap_Free+0x1b0>
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
ffc11284: 81 09 00 38 lwz r8,56(r9)
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
ffc11288: 7f e7 fa 14 add r31,r7,r31
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
ffc1128c: 81 6a 00 08 lwz r11,8(r10)
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
ffc11290: 7c bf 2a 14 add r5,r31,r5
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
ffc11294: 81 4a 00 0c lwz r10,12(r10)
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
ffc11298: 39 08 ff ff addi r8,r8,-1
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
ffc1129c: 60 a0 00 01 ori r0,r5,1
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
prev->next = next;
ffc112a0: 91 6a 00 08 stw r11,8(r10)
next->prev = prev;
ffc112a4: 91 4b 00 0c stw r10,12(r11)
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
ffc112a8: 91 09 00 38 stw r8,56(r9)
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
ffc112ac: 90 0c 00 04 stw r0,4(r12)
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
ffc112b0: 7c a5 61 2e stwx r5,r5,r12
ffc112b4: 48 00 00 34 b ffc112e8 <_Heap_Free+0x130>
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
ffc112b8: 2f 86 00 00 cmpwi cr7,r6,0
ffc112bc: 41 9e 00 60 beq- cr7,ffc1131c <_Heap_Free+0x164>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
ffc112c0: 81 6a 00 08 lwz r11,8(r10)
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
uintptr_t const size = block_size + next_block_size;
ffc112c4: 7c a5 3a 14 add r5,r5,r7
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
ffc112c8: 81 4a 00 0c lwz r10,12(r10)
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
uintptr_t const size = block_size + next_block_size;
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
ffc112cc: 60 a0 00 01 ori r0,r5,1
)
{
Heap_Block *next = old_block->next;
Heap_Block *prev = old_block->prev;
new_block->next = next;
ffc112d0: 91 64 00 08 stw r11,8(r4)
new_block->prev = prev;
ffc112d4: 91 44 00 0c stw r10,12(r4)
next->prev = new_block;
prev->next = new_block;
ffc112d8: 90 8a 00 08 stw r4,8(r10)
Heap_Block *prev = old_block->prev;
new_block->next = next;
new_block->prev = prev;
next->prev = new_block;
ffc112dc: 90 8b 00 0c stw r4,12(r11)
ffc112e0: 90 04 00 04 stw r0,4(r4)
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
ffc112e4: 7c a5 21 2e stwx r5,r5,r4
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
ffc112e8: 81 69 00 40 lwz r11,64(r9)
++stats->frees;
stats->free_size += block_size;
return( true );
ffc112ec: 38 60 00 01 li r3,1
}
}
/* Statistics */
--stats->used_blocks;
++stats->frees;
ffc112f0: 81 09 00 50 lwz r8,80(r9)
stats->free_size += block_size;
ffc112f4: 81 49 00 30 lwz r10,48(r9)
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
ffc112f8: 39 6b ff ff addi r11,r11,-1
++stats->frees;
ffc112fc: 38 08 00 01 addi r0,r8,1
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
ffc11300: 91 69 00 40 stw r11,64(r9)
++stats->frees;
stats->free_size += block_size;
ffc11304: 7c ea 3a 14 add r7,r10,r7
}
}
/* Statistics */
--stats->used_blocks;
++stats->frees;
ffc11308: 90 09 00 50 stw r0,80(r9)
stats->free_size += block_size;
ffc1130c: 90 e9 00 30 stw r7,48(r9)
return( true );
}
ffc11310: 83 e1 00 0c lwz r31,12(r1)
ffc11314: 38 21 00 10 addi r1,r1,16
ffc11318: 4e 80 00 20 blr
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;
ffc1131c: 81 09 00 38 lwz r8,56(r9)
if ( stats->max_free_blocks < stats->free_blocks ) {
ffc11320: 81 69 00 3c lwz r11,60(r9)
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;
ffc11324: 38 08 00 01 addi r0,r8,1
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
ffc11328: 91 24 00 0c stw r9,12(r4)
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;
ffc1132c: 60 e8 00 01 ori r8,r7,1
ffc11330: 91 04 00 04 stw r8,4(r4)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
if ( stats->max_free_blocks < stats->free_blocks ) {
ffc11334: 7f 80 58 40 cmplw cr7,r0,r11
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
ffc11338: 81 0a 00 04 lwz r8,4(r10)
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
ffc1133c: 81 69 00 08 lwz r11,8(r9)
ffc11340: 55 08 00 3c rlwinm r8,r8,0,0,30
next_block->prev_size = block_size;
ffc11344: 7c e7 21 2e stwx r7,r7,r4
new_block->next = next;
ffc11348: 91 64 00 08 stw r11,8(r4)
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
ffc1134c: 91 0a 00 04 stw r8,4(r10)
new_block->prev = block_before;
block_before->next = new_block;
next->prev = new_block;
ffc11350: 90 8b 00 0c stw r4,12(r11)
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
block_before->next = new_block;
ffc11354: 90 89 00 08 stw r4,8(r9)
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
ffc11358: 90 09 00 38 stw r0,56(r9)
if ( stats->max_free_blocks < stats->free_blocks ) {
ffc1135c: 40 bd ff 8c ble- cr7,ffc112e8 <_Heap_Free+0x130>
stats->max_free_blocks = stats->free_blocks;
ffc11360: 90 09 00 3c stw r0,60(r9)
ffc11364: 4b ff ff 84 b ffc112e8 <_Heap_Free+0x130>
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
ffc11368: 7f e7 fa 14 add r31,r7,r31
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
ffc1136c: 63 e0 00 01 ori r0,r31,1
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
ffc11370: 7f e7 21 2e stwx r31,r7,r4
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
ffc11374: 90 0c 00 04 stw r0,4(r12)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
ffc11378: 80 0a 00 04 lwz r0,4(r10)
ffc1137c: 54 00 00 3c rlwinm r0,r0,0,0,30
ffc11380: 90 0a 00 04 stw r0,4(r10)
ffc11384: 4b ff ff 64 b ffc112e8 <_Heap_Free+0x130>
ffc0b3f8 <_Heap_Walk>:
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;
ffc0b3f8: 2f 85 00 00 cmpwi cr7,r5,0
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
ffc0b3fc: 94 21 ff 98 stwu r1,-104(r1)
ffc0b400: 7c 08 02 a6 mflr r0
ffc0b404: 92 e1 00 44 stw r23,68(r1)
ffc0b408: 90 01 00 6c stw r0,108(r1)
ffc0b40c: 93 01 00 48 stw r24,72(r1)
ffc0b410: 93 21 00 4c stw r25,76(r1)
ffc0b414: 7c 99 23 78 mr r25,r4
ffc0b418: 93 41 00 50 stw r26,80(r1)
ffc0b41c: 93 61 00 54 stw r27,84(r1)
ffc0b420: 93 e1 00 64 stw r31,100(r1)
ffc0b424: 7c 7f 1b 78 mr r31,r3
ffc0b428: 91 c1 00 20 stw r14,32(r1)
ffc0b42c: 91 e1 00 24 stw r15,36(r1)
ffc0b430: 92 01 00 28 stw r16,40(r1)
ffc0b434: 92 21 00 2c stw r17,44(r1)
ffc0b438: 92 41 00 30 stw r18,48(r1)
ffc0b43c: 92 61 00 34 stw r19,52(r1)
ffc0b440: 92 81 00 38 stw r20,56(r1)
ffc0b444: 92 a1 00 3c stw r21,60(r1)
ffc0b448: 92 c1 00 40 stw r22,64(r1)
ffc0b44c: 93 81 00 58 stw r28,88(r1)
ffc0b450: 93 a1 00 5c stw r29,92(r1)
ffc0b454: 93 c1 00 60 stw r30,96(r1)
uintptr_t const page_size = heap->page_size;
ffc0b458: 83 63 00 10 lwz r27,16(r3)
uintptr_t const min_block_size = heap->min_block_size;
ffc0b45c: 83 03 00 14 lwz r24,20(r3)
Heap_Block *const first_block = heap->first_block;
ffc0b460: 83 43 00 20 lwz r26,32(r3)
Heap_Block *const last_block = heap->last_block;
ffc0b464: 82 e3 00 24 lwz r23,36(r3)
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
ffc0b468: 41 9e 00 7c beq- cr7,ffc0b4e4 <_Heap_Walk+0xec>
ffc0b46c: 3d 20 ff c1 lis r9,-63
ffc0b470: 39 29 b2 f8 addi r9,r9,-19720
ffc0b474: 91 21 00 18 stw r9,24(r1)
if ( !_System_state_Is_up( _System_state_Get() ) ) {
ffc0b478: 3d 20 00 00 lis r9,0
return true;
ffc0b47c: 38 60 00 01 li 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() ) ) {
ffc0b480: 80 09 28 24 lwz r0,10276(r9)
ffc0b484: 2f 80 00 03 cmpwi cr7,r0,3
ffc0b488: 41 9e 00 7c beq- cr7,ffc0b504 <_Heap_Walk+0x10c> <== ALWAYS TAKEN
block = next_block;
} while ( block != first_block );
return true;
}
ffc0b48c: 80 01 00 6c lwz r0,108(r1)
ffc0b490: 81 c1 00 20 lwz r14,32(r1)
ffc0b494: 7c 08 03 a6 mtlr r0
ffc0b498: 81 e1 00 24 lwz r15,36(r1)
ffc0b49c: 82 01 00 28 lwz r16,40(r1)
ffc0b4a0: 82 21 00 2c lwz r17,44(r1)
ffc0b4a4: 82 41 00 30 lwz r18,48(r1)
ffc0b4a8: 82 61 00 34 lwz r19,52(r1)
ffc0b4ac: 82 81 00 38 lwz r20,56(r1)
ffc0b4b0: 82 a1 00 3c lwz r21,60(r1)
ffc0b4b4: 82 c1 00 40 lwz r22,64(r1)
ffc0b4b8: 82 e1 00 44 lwz r23,68(r1)
ffc0b4bc: 83 01 00 48 lwz r24,72(r1)
ffc0b4c0: 83 21 00 4c lwz r25,76(r1)
ffc0b4c4: 83 41 00 50 lwz r26,80(r1)
ffc0b4c8: 83 61 00 54 lwz r27,84(r1)
ffc0b4cc: 83 81 00 58 lwz r28,88(r1)
ffc0b4d0: 83 a1 00 5c lwz r29,92(r1)
ffc0b4d4: 83 c1 00 60 lwz r30,96(r1)
ffc0b4d8: 83 e1 00 64 lwz r31,100(r1)
ffc0b4dc: 38 21 00 68 addi r1,r1,104
ffc0b4e0: 4e 80 00 20 blr
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;
ffc0b4e4: 3d 20 ff c1 lis r9,-63
ffc0b4e8: 39 29 b2 f4 addi r9,r9,-19724
ffc0b4ec: 91 21 00 18 stw r9,24(r1)
if ( !_System_state_Is_up( _System_state_Get() ) ) {
ffc0b4f0: 3d 20 00 00 lis r9,0
return true;
ffc0b4f4: 38 60 00 01 li 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() ) ) {
ffc0b4f8: 80 09 28 24 lwz r0,10276(r9)
ffc0b4fc: 2f 80 00 03 cmpwi cr7,r0,3
ffc0b500: 40 9e ff 8c bne+ cr7,ffc0b48c <_Heap_Walk+0x94>
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)(
ffc0b504: 80 1f 00 0c lwz r0,12(r31)
ffc0b508: 3c a0 ff c2 lis r5,-62
ffc0b50c: 81 1f 00 18 lwz r8,24(r31)
ffc0b510: 7f 23 cb 78 mr r3,r25
ffc0b514: 81 3f 00 1c lwz r9,28(r31)
ffc0b518: 38 80 00 00 li r4,0
ffc0b51c: 81 7f 00 08 lwz r11,8(r31)
ffc0b520: 38 a5 b9 9c addi r5,r5,-18020
ffc0b524: 90 01 00 10 stw r0,16(r1)
ffc0b528: 7f 66 db 78 mr r6,r27
ffc0b52c: 7f 07 c3 78 mr r7,r24
ffc0b530: 80 01 00 18 lwz r0,24(r1)
ffc0b534: 7f 4a d3 78 mr r10,r26
ffc0b538: 92 e1 00 08 stw r23,8(r1)
ffc0b53c: 7c 09 03 a6 mtctr r0
ffc0b540: 91 61 00 0c stw r11,12(r1)
ffc0b544: 4c c6 31 82 crclr 4*cr1+eq
ffc0b548: 4e 80 04 21 bctrl
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
ffc0b54c: 2f 9b 00 00 cmpwi cr7,r27,0
ffc0b550: 41 9e 00 ac beq- cr7,ffc0b5fc <_Heap_Walk+0x204>
(*printer)( source, true, "page size is zero\n" );
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
ffc0b554: 73 67 00 07 andi. r7,r27,7
ffc0b558: 40 82 00 cc bne- ffc0b624 <_Heap_Walk+0x22c>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
ffc0b55c: 7c 18 db 96 divwu r0,r24,r27
ffc0b560: 7c 00 d9 d6 mullw r0,r0,r27
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
ffc0b564: 7f 98 00 00 cmpw cr7,r24,r0
ffc0b568: 40 9e 00 e8 bne- cr7,ffc0b650 <_Heap_Walk+0x258>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
ffc0b56c: 38 1a 00 08 addi r0,r26,8
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
ffc0b570: 7d 20 db 96 divwu r9,r0,r27
ffc0b574: 7d 29 d9 d6 mullw r9,r9,r27
);
return false;
}
if (
ffc0b578: 7f 80 48 00 cmpw cr7,r0,r9
ffc0b57c: 40 9e 01 00 bne- cr7,ffc0b67c <_Heap_Walk+0x284>
block = next_block;
} while ( block != first_block );
return true;
}
ffc0b580: 82 da 00 04 lwz r22,4(r26)
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
ffc0b584: 72 c7 00 01 andi. r7,r22,1
ffc0b588: 41 82 01 20 beq- ffc0b6a8 <_Heap_Walk+0x2b0>
- 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;
ffc0b58c: 81 37 00 04 lwz r9,4(r23)
ffc0b590: 55 29 00 3c rlwinm r9,r9,0,0,30
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
ffc0b594: 7d 37 4a 14 add r9,r23,r9
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;
ffc0b598: 80 09 00 04 lwz r0,4(r9)
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
ffc0b59c: 70 07 00 01 andi. r7,r0,1
ffc0b5a0: 41 82 00 34 beq- ffc0b5d4 <_Heap_Walk+0x1dc>
);
return false;
}
if (
ffc0b5a4: 7f 9a 48 00 cmpw cr7,r26,r9
ffc0b5a8: 41 9e 01 28 beq- cr7,ffc0b6d0 <_Heap_Walk+0x2d8>
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
ffc0b5ac: 80 01 00 18 lwz r0,24(r1)
ffc0b5b0: 3c a0 ff c2 lis r5,-62
ffc0b5b4: 7f 23 cb 78 mr r3,r25
ffc0b5b8: 38 80 00 01 li r4,1
ffc0b5bc: 7c 09 03 a6 mtctr r0
ffc0b5c0: 38 a5 bb 04 addi r5,r5,-17660
ffc0b5c4: 4c c6 31 82 crclr 4*cr1+eq
ffc0b5c8: 4e 80 04 21 bctrl
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
ffc0b5cc: 38 60 00 00 li r3,0
ffc0b5d0: 4b ff fe bc b ffc0b48c <_Heap_Walk+0x94>
return false;
}
if ( _Heap_Is_free( last_block ) ) {
(*printer)(
ffc0b5d4: 80 01 00 18 lwz r0,24(r1)
ffc0b5d8: 3c a0 ff c2 lis r5,-62
ffc0b5dc: 7f 23 cb 78 mr r3,r25
ffc0b5e0: 38 80 00 01 li r4,1
ffc0b5e4: 7c 09 03 a6 mtctr r0
ffc0b5e8: 38 a5 ba ec addi r5,r5,-17684
ffc0b5ec: 4c c6 31 82 crclr 4*cr1+eq
ffc0b5f0: 4e 80 04 21 bctrl
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
ffc0b5f4: 38 60 00 00 li r3,0
ffc0b5f8: 4b ff fe 94 b ffc0b48c <_Heap_Walk+0x94>
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
(*printer)( source, true, "page size is zero\n" );
ffc0b5fc: 80 01 00 18 lwz r0,24(r1)
ffc0b600: 3c a0 ff c2 lis r5,-62
ffc0b604: 7f 23 cb 78 mr r3,r25
ffc0b608: 38 80 00 01 li r4,1
ffc0b60c: 7c 09 03 a6 mtctr r0
ffc0b610: 38 a5 ba 30 addi r5,r5,-17872
ffc0b614: 4c c6 31 82 crclr 4*cr1+eq
ffc0b618: 4e 80 04 21 bctrl
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
ffc0b61c: 38 60 00 00 li r3,0
ffc0b620: 4b ff fe 6c b ffc0b48c <_Heap_Walk+0x94>
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
(*printer)(
ffc0b624: 80 01 00 18 lwz r0,24(r1)
ffc0b628: 3c a0 ff c2 lis r5,-62
ffc0b62c: 7f 23 cb 78 mr r3,r25
ffc0b630: 38 80 00 01 li r4,1
ffc0b634: 7c 09 03 a6 mtctr r0
ffc0b638: 38 a5 ba 44 addi r5,r5,-17852
ffc0b63c: 7f 66 db 78 mr r6,r27
ffc0b640: 4c c6 31 82 crclr 4*cr1+eq
ffc0b644: 4e 80 04 21 bctrl
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
ffc0b648: 38 60 00 00 li r3,0
ffc0b64c: 4b ff fe 40 b ffc0b48c <_Heap_Walk+0x94>
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
(*printer)(
ffc0b650: 80 01 00 18 lwz r0,24(r1)
ffc0b654: 3c a0 ff c2 lis r5,-62
ffc0b658: 7f 23 cb 78 mr r3,r25
ffc0b65c: 38 80 00 01 li r4,1
ffc0b660: 7c 09 03 a6 mtctr r0
ffc0b664: 38 a5 ba 64 addi r5,r5,-17820
ffc0b668: 7f 06 c3 78 mr r6,r24
ffc0b66c: 4c c6 31 82 crclr 4*cr1+eq
ffc0b670: 4e 80 04 21 bctrl
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
ffc0b674: 38 60 00 00 li r3,0
ffc0b678: 4b ff fe 14 b ffc0b48c <_Heap_Walk+0x94>
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
ffc0b67c: 80 01 00 18 lwz r0,24(r1)
ffc0b680: 3c a0 ff c2 lis r5,-62
ffc0b684: 7f 23 cb 78 mr r3,r25
ffc0b688: 38 80 00 01 li r4,1
ffc0b68c: 7c 09 03 a6 mtctr r0
ffc0b690: 38 a5 ba 88 addi r5,r5,-17784
ffc0b694: 7f 46 d3 78 mr r6,r26
ffc0b698: 4c c6 31 82 crclr 4*cr1+eq
ffc0b69c: 4e 80 04 21 bctrl
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
ffc0b6a0: 38 60 00 00 li r3,0
ffc0b6a4: 4b ff fd e8 b ffc0b48c <_Heap_Walk+0x94>
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
(*printer)(
ffc0b6a8: 80 01 00 18 lwz r0,24(r1)
ffc0b6ac: 3c a0 ff c2 lis r5,-62
ffc0b6b0: 7f 23 cb 78 mr r3,r25
ffc0b6b4: 38 80 00 01 li r4,1
ffc0b6b8: 7c 09 03 a6 mtctr r0
ffc0b6bc: 38 a5 ba bc addi r5,r5,-17732
ffc0b6c0: 4c c6 31 82 crclr 4*cr1+eq
ffc0b6c4: 4e 80 04 21 bctrl
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
ffc0b6c8: 38 60 00 00 li r3,0
ffc0b6cc: 4b ff fd c0 b ffc0b48c <_Heap_Walk+0x94>
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
ffc0b6d0: 80 df 00 08 lwz r6,8(r31)
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
ffc0b6d4: 81 1f 00 10 lwz r8,16(r31)
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 ) {
ffc0b6d8: 7f 9f 30 00 cmpw cr7,r31,r6
block = next_block;
} while ( block != first_block );
return true;
}
ffc0b6dc: 80 1f 00 20 lwz r0,32(r31)
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 ) {
ffc0b6e0: 41 9e 00 34 beq- cr7,ffc0b714 <_Heap_Walk+0x31c>
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;
ffc0b6e4: 7f 80 30 40 cmplw cr7,r0,r6
ffc0b6e8: 40 9d 03 24 ble- cr7,ffc0ba0c <_Heap_Walk+0x614> <== ALWAYS TAKEN
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
(*printer)(
ffc0b6ec: 80 01 00 18 lwz r0,24(r1)
ffc0b6f0: 3c a0 ff c2 lis r5,-62
ffc0b6f4: 7f 23 cb 78 mr r3,r25
ffc0b6f8: 38 80 00 01 li r4,1
ffc0b6fc: 7c 09 03 a6 mtctr r0
ffc0b700: 38 a5 bb 34 addi r5,r5,-17612
ffc0b704: 4c c6 31 82 crclr 4*cr1+eq
ffc0b708: 4e 80 04 21 bctrl
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
ffc0b70c: 38 60 00 00 li r3,0
ffc0b710: 4b ff fd 7c b ffc0b48c <_Heap_Walk+0x94>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
ffc0b714: 3e 60 ff c2 lis r19,-62
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
(*printer)(
ffc0b718: 3e 80 ff c2 lis r20,-62
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)(
ffc0b71c: 3e 40 ff c2 lis r18,-62
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
ffc0b720: 7f 5d d3 78 mr r29,r26
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
ffc0b724: 3a 73 bd 50 addi r19,r19,-17072
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
(*printer)(
ffc0b728: 3a 94 bd 38 addi r20,r20,-17096
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)(
ffc0b72c: 3a 52 bc 94 addi r18,r18,-17260
ffc0b730: 3e 20 ff c2 lis r17,-62
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
ffc0b734: 3e a0 ff c2 lis r21,-62
ffc0b738: 3d e0 ff c2 lis r15,-62
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)(
ffc0b73c: 3e 00 ff c2 lis r16,-62
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
ffc0b740: 3d c0 ff c2 lis r14,-62
- 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;
ffc0b744: 56 dc 00 3c rlwinm r28,r22,0,0,30
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
ffc0b748: 7f dc ea 14 add r30,r28,r29
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;
ffc0b74c: 7f 80 f0 40 cmplw cr7,r0,r30
ffc0b750: 40 9d 00 34 ble- cr7,ffc0b784 <_Heap_Walk+0x38c> <== ALWAYS TAKEN
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
(*printer)(
ffc0b754: 3c a0 ff c2 lis r5,-62
ffc0b758: 7f 23 cb 78 mr r3,r25
ffc0b75c: 38 80 00 01 li r4,1
ffc0b760: 38 a5 bb d4 addi r5,r5,-17452
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
(*printer)(
ffc0b764: 80 01 00 18 lwz r0,24(r1)
ffc0b768: 7f a6 eb 78 mr r6,r29
ffc0b76c: 7f c7 f3 78 mr r7,r30
ffc0b770: 7c 09 03 a6 mtctr r0
ffc0b774: 4c c6 31 82 crclr 4*cr1+eq
ffc0b778: 4e 80 04 21 bctrl
"block 0x%08x: next block 0x%08x is not a successor\n",
block,
next_block
);
return false;
ffc0b77c: 38 60 00 00 li r3,0
ffc0b780: 4b ff fd 0c b ffc0b48c <_Heap_Walk+0x94>
ffc0b784: 80 1f 00 24 lwz r0,36(r31)
ffc0b788: 7f 80 f0 40 cmplw cr7,r0,r30
ffc0b78c: 41 bc ff c8 blt- cr7,ffc0b754 <_Heap_Walk+0x35c>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
ffc0b790: 7d 3c db 96 divwu r9,r28,r27
ffc0b794: 7d 29 d9 d6 mullw r9,r9,r27
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;
ffc0b798: 7f a0 ba 78 xor r0,r29,r23
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
ffc0b79c: 7f 9c 48 00 cmpw cr7,r28,r9
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;
ffc0b7a0: 7c 00 00 34 cntlzw r0,r0
ffc0b7a4: 54 00 d9 7e rlwinm r0,r0,27,5,31
ffc0b7a8: 68 00 00 01 xori r0,r0,1
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
ffc0b7ac: 41 9e 00 0c beq- cr7,ffc0b7b8 <_Heap_Walk+0x3c0>
ffc0b7b0: 2f 80 00 00 cmpwi cr7,r0,0
ffc0b7b4: 40 9e 01 e0 bne- cr7,ffc0b994 <_Heap_Walk+0x59c>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
ffc0b7b8: 7f 98 e0 40 cmplw cr7,r24,r28
ffc0b7bc: 40 9d 00 0c ble- cr7,ffc0b7c8 <_Heap_Walk+0x3d0>
ffc0b7c0: 2f 80 00 00 cmpwi cr7,r0,0
ffc0b7c4: 40 9e 02 00 bne- cr7,ffc0b9c4 <_Heap_Walk+0x5cc> <== ALWAYS TAKEN
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
ffc0b7c8: 7f 9d f0 40 cmplw cr7,r29,r30
ffc0b7cc: 41 9c 00 0c blt- cr7,ffc0b7d8 <_Heap_Walk+0x3e0>
ffc0b7d0: 2f 80 00 00 cmpwi cr7,r0,0
ffc0b7d4: 40 9e 02 24 bne- cr7,ffc0b9f8 <_Heap_Walk+0x600>
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;
ffc0b7d8: 80 1e 00 04 lwz r0,4(r30)
ffc0b7dc: 56 d6 07 fe clrlwi r22,r22,31
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
ffc0b7e0: 70 07 00 01 andi. r7,r0,1
ffc0b7e4: 41 82 00 74 beq- ffc0b858 <_Heap_Walk+0x460>
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
ffc0b7e8: 2f 96 00 00 cmpwi cr7,r22,0
ffc0b7ec: 41 9e 00 40 beq- cr7,ffc0b82c <_Heap_Walk+0x434>
(*printer)(
ffc0b7f0: 80 01 00 18 lwz r0,24(r1)
ffc0b7f4: 7f 23 cb 78 mr r3,r25
ffc0b7f8: 38 80 00 00 li r4,0
ffc0b7fc: 7e 85 a3 78 mr r5,r20
ffc0b800: 7c 09 03 a6 mtctr r0
ffc0b804: 7f a6 eb 78 mr r6,r29
ffc0b808: 7f 87 e3 78 mr r7,r28
ffc0b80c: 4c c6 31 82 crclr 4*cr1+eq
ffc0b810: 4e 80 04 21 bctrl
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
ffc0b814: 7f 9a f0 00 cmpw cr7,r26,r30
ffc0b818: 41 9e 01 0c beq- cr7,ffc0b924 <_Heap_Walk+0x52c>
ffc0b81c: 82 de 00 04 lwz r22,4(r30)
ffc0b820: 7f dd f3 78 mr r29,r30
ffc0b824: 80 1f 00 20 lwz r0,32(r31)
ffc0b828: 4b ff ff 1c b ffc0b744 <_Heap_Walk+0x34c>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
ffc0b82c: 80 01 00 18 lwz r0,24(r1)
ffc0b830: 7f a6 eb 78 mr r6,r29
ffc0b834: 7f 23 cb 78 mr r3,r25
ffc0b838: 81 1d 00 00 lwz r8,0(r29)
ffc0b83c: 38 80 00 00 li r4,0
ffc0b840: 7c 09 03 a6 mtctr r0
ffc0b844: 7e 65 9b 78 mr r5,r19
ffc0b848: 7f 87 e3 78 mr r7,r28
ffc0b84c: 4c c6 31 82 crclr 4*cr1+eq
ffc0b850: 4e 80 04 21 bctrl
ffc0b854: 4b ff ff c0 b ffc0b814 <_Heap_Walk+0x41c>
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 ?
ffc0b858: 81 1d 00 0c lwz r8,12(r29)
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)(
ffc0b85c: 81 3f 00 08 lwz r9,8(r31)
return _Heap_Free_list_head(heap)->next;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_last( Heap_Control *heap )
{
return _Heap_Free_list_tail(heap)->prev;
ffc0b860: 80 1f 00 0c lwz r0,12(r31)
ffc0b864: 7f 89 40 00 cmpw cr7,r9,r8
ffc0b868: 41 9e 00 f8 beq- cr7,ffc0b960 <_Heap_Walk+0x568>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
ffc0b86c: 7f 9f 40 00 cmpw cr7,r31,r8
ffc0b870: 41 9e 01 00 beq- cr7,ffc0b970 <_Heap_Walk+0x578>
ffc0b874: 39 35 bd 04 addi r9,r21,-17148
block->next,
block->next == last_free_block ?
ffc0b878: 81 5d 00 08 lwz r10,8(r29)
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)(
ffc0b87c: 7f 80 50 00 cmpw cr7,r0,r10
ffc0b880: 41 9e 00 e8 beq- cr7,ffc0b968 <_Heap_Walk+0x570>
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
ffc0b884: 7f 9f 50 00 cmpw cr7,r31,r10
ffc0b888: 41 9e 00 f0 beq- cr7,ffc0b978 <_Heap_Walk+0x580>
ffc0b88c: 38 15 bd 04 addi r0,r21,-17148
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)(
ffc0b890: 90 01 00 08 stw r0,8(r1)
ffc0b894: 7f 23 cb 78 mr r3,r25
ffc0b898: 38 80 00 00 li r4,0
ffc0b89c: 80 01 00 18 lwz r0,24(r1)
ffc0b8a0: 7e 45 93 78 mr r5,r18
ffc0b8a4: 7f a6 eb 78 mr r6,r29
ffc0b8a8: 7f 87 e3 78 mr r7,r28
ffc0b8ac: 7c 09 03 a6 mtctr r0
ffc0b8b0: 4c c6 31 82 crclr 4*cr1+eq
ffc0b8b4: 4e 80 04 21 bctrl
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
ffc0b8b8: 81 1e 00 00 lwz r8,0(r30)
ffc0b8bc: 7f 9c 40 00 cmpw cr7,r28,r8
ffc0b8c0: 40 9e 00 6c bne- cr7,ffc0b92c <_Heap_Walk+0x534>
);
return false;
}
if ( !prev_used ) {
ffc0b8c4: 2f 96 00 00 cmpwi cr7,r22,0
ffc0b8c8: 41 9e 00 b8 beq- cr7,ffc0b980 <_Heap_Walk+0x588>
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
ffc0b8cc: 81 3f 00 08 lwz r9,8(r31)
)
{
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 ) {
ffc0b8d0: 7f 9f 48 00 cmpw cr7,r31,r9
ffc0b8d4: 41 9e 00 24 beq- cr7,ffc0b8f8 <_Heap_Walk+0x500> <== NEVER TAKEN
if ( free_block == block ) {
ffc0b8d8: 7f 9d 48 00 cmpw cr7,r29,r9
ffc0b8dc: 40 be 00 0c bne+ cr7,ffc0b8e8 <_Heap_Walk+0x4f0>
ffc0b8e0: 4b ff ff 34 b ffc0b814 <_Heap_Walk+0x41c>
ffc0b8e4: 41 ba ff 30 beq- cr6,ffc0b814 <_Heap_Walk+0x41c>
return true;
}
free_block = free_block->next;
ffc0b8e8: 81 29 00 08 lwz r9,8(r9)
)
{
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 ) {
ffc0b8ec: 7f 9f 48 00 cmpw cr7,r31,r9
if ( free_block == block ) {
ffc0b8f0: 7f 1d 48 00 cmpw cr6,r29,r9
)
{
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 ) {
ffc0b8f4: 40 9e ff f0 bne+ cr7,ffc0b8e4 <_Heap_Walk+0x4ec>
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
ffc0b8f8: 3c a0 ff c2 lis r5,-62
ffc0b8fc: 7f 23 cb 78 mr r3,r25
ffc0b900: 38 80 00 01 li r4,1
ffc0b904: 38 a5 bd 78 addi r5,r5,-17032
ffc0b908: 80 01 00 18 lwz r0,24(r1)
ffc0b90c: 7f a6 eb 78 mr r6,r29
ffc0b910: 7c 09 03 a6 mtctr r0
ffc0b914: 4c c6 31 82 crclr 4*cr1+eq
ffc0b918: 4e 80 04 21 bctrl
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
ffc0b91c: 38 60 00 00 li r3,0
ffc0b920: 4b ff fb 6c b ffc0b48c <_Heap_Walk+0x94>
}
block = next_block;
} while ( block != first_block );
return true;
ffc0b924: 38 60 00 01 li r3,1
ffc0b928: 4b ff fb 64 b ffc0b48c <_Heap_Walk+0x94>
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
(*printer)(
ffc0b92c: 80 01 00 18 lwz r0,24(r1)
ffc0b930: 3c a0 ff c2 lis r5,-62
ffc0b934: 7f 23 cb 78 mr r3,r25
ffc0b938: 38 80 00 01 li r4,1
ffc0b93c: 7c 09 03 a6 mtctr r0
ffc0b940: 38 a5 bc cc addi r5,r5,-17204
ffc0b944: 7f a6 eb 78 mr r6,r29
ffc0b948: 7f 87 e3 78 mr r7,r28
ffc0b94c: 7f c9 f3 78 mr r9,r30
ffc0b950: 4c c6 31 82 crclr 4*cr1+eq
ffc0b954: 4e 80 04 21 bctrl
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
ffc0b958: 38 60 00 00 li r3,0
ffc0b95c: 4b ff fb 30 b ffc0b48c <_Heap_Walk+0x94>
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)(
ffc0b960: 39 30 b9 64 addi r9,r16,-18076
ffc0b964: 4b ff ff 14 b ffc0b878 <_Heap_Walk+0x480>
ffc0b968: 38 11 b9 80 addi r0,r17,-18048
ffc0b96c: 4b ff ff 24 b ffc0b890 <_Heap_Walk+0x498>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
ffc0b970: 39 2e b9 74 addi r9,r14,-18060
ffc0b974: 4b ff ff 04 b ffc0b878 <_Heap_Walk+0x480>
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
ffc0b978: 38 0f b9 90 addi r0,r15,-18032
ffc0b97c: 4b ff ff 14 b ffc0b890 <_Heap_Walk+0x498>
return false;
}
if ( !prev_used ) {
(*printer)(
ffc0b980: 3c a0 ff c2 lis r5,-62
ffc0b984: 7f 23 cb 78 mr r3,r25
ffc0b988: 38 80 00 01 li r4,1
ffc0b98c: 38 a5 bd 08 addi r5,r5,-17144
ffc0b990: 4b ff ff 78 b ffc0b908 <_Heap_Walk+0x510>
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
(*printer)(
ffc0b994: 80 01 00 18 lwz r0,24(r1)
ffc0b998: 3c a0 ff c2 lis r5,-62
ffc0b99c: 7f 23 cb 78 mr r3,r25
ffc0b9a0: 38 80 00 01 li r4,1
ffc0b9a4: 7c 09 03 a6 mtctr r0
ffc0b9a8: 38 a5 bc 04 addi r5,r5,-17404
ffc0b9ac: 7f a6 eb 78 mr r6,r29
ffc0b9b0: 7f 87 e3 78 mr r7,r28
ffc0b9b4: 4c c6 31 82 crclr 4*cr1+eq
ffc0b9b8: 4e 80 04 21 bctrl
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
ffc0b9bc: 38 60 00 00 li r3,0
ffc0b9c0: 4b ff fa cc b ffc0b48c <_Heap_Walk+0x94>
}
if ( block_size < min_block_size && is_not_last_block ) {
(*printer)(
ffc0b9c4: 80 01 00 18 lwz r0,24(r1)
ffc0b9c8: 3c a0 ff c2 lis r5,-62
ffc0b9cc: 7f 23 cb 78 mr r3,r25
ffc0b9d0: 38 80 00 01 li r4,1
ffc0b9d4: 7c 09 03 a6 mtctr r0
ffc0b9d8: 38 a5 bc 34 addi r5,r5,-17356
ffc0b9dc: 7f a6 eb 78 mr r6,r29
ffc0b9e0: 7f 87 e3 78 mr r7,r28
ffc0b9e4: 7f 08 c3 78 mr r8,r24
ffc0b9e8: 4c c6 31 82 crclr 4*cr1+eq
ffc0b9ec: 4e 80 04 21 bctrl
block,
block_size,
min_block_size
);
return false;
ffc0b9f0: 38 60 00 00 li r3,0
ffc0b9f4: 4b ff fa 98 b ffc0b48c <_Heap_Walk+0x94>
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
(*printer)(
ffc0b9f8: 3c a0 ff c2 lis r5,-62
ffc0b9fc: 7f 23 cb 78 mr r3,r25
ffc0ba00: 38 80 00 01 li r4,1
ffc0ba04: 38 a5 bc 60 addi r5,r5,-17312
ffc0ba08: 4b ff fd 5c b ffc0b764 <_Heap_Walk+0x36c>
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;
ffc0ba0c: 81 5f 00 24 lwz r10,36(r31)
ffc0ba10: 7f 86 50 40 cmplw cr7,r6,r10
ffc0ba14: 41 bd fc d8 bgt- cr7,ffc0b6ec <_Heap_Walk+0x2f4> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
ffc0ba18: 39 26 00 08 addi r9,r6,8
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
ffc0ba1c: 7d 69 43 96 divwu r11,r9,r8
ffc0ba20: 7d 6b 41 d6 mullw r11,r11,r8
);
return false;
}
if (
ffc0ba24: 7f 89 58 00 cmpw cr7,r9,r11
ffc0ba28: 40 9e 00 d4 bne- cr7,ffc0bafc <_Heap_Walk+0x704> <== 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;
ffc0ba2c: 81 26 00 04 lwz r9,4(r6)
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
ffc0ba30: 7f eb fb 78 mr r11,r31
ffc0ba34: 7c c5 33 78 mr r5,r6
ffc0ba38: 55 29 00 3c rlwinm r9,r9,0,0,30
block = next_block;
} while ( block != first_block );
return true;
}
ffc0ba3c: 7d 26 4a 14 add r9,r6,r9
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;
ffc0ba40: 81 29 00 04 lwz r9,4(r9)
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
ffc0ba44: 71 27 00 01 andi. r7,r9,1
ffc0ba48: 41 a2 00 58 beq+ ffc0baa0 <_Heap_Walk+0x6a8> <== ALWAYS TAKEN
ffc0ba4c: 48 00 00 88 b ffc0bad4 <_Heap_Walk+0x6dc> <== NOT EXECUTED
return false;
}
prev_block = free_block;
free_block = free_block->next;
ffc0ba50: 80 c6 00 08 lwz r6,8(r6)
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 ) {
ffc0ba54: 7f 9f 30 00 cmpw cr7,r31,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;
ffc0ba58: 7f 06 00 40 cmplw cr6,r6,r0
ffc0ba5c: 7c 86 50 40 cmplw cr1,r6,r10
ffc0ba60: 41 be fc b4 beq- cr7,ffc0b714 <_Heap_Walk+0x31c>
ffc0ba64: 41 b8 fc 88 blt- cr6,ffc0b6ec <_Heap_Walk+0x2f4>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
ffc0ba68: 39 26 00 08 addi r9,r6,8
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;
ffc0ba6c: 41 a5 fc 80 bgt- cr1,ffc0b6ec <_Heap_Walk+0x2f4> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
ffc0ba70: 7c e9 43 96 divwu r7,r9,r8
ffc0ba74: 7c e7 41 d6 mullw r7,r7,r8
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
ffc0ba78: 7c ab 2b 78 mr r11,r5
);
return false;
}
if (
ffc0ba7c: 7f 89 38 00 cmpw cr7,r9,r7
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
ffc0ba80: 7c c5 33 78 mr r5,r6
);
return false;
}
if (
ffc0ba84: 40 9e 00 78 bne- cr7,ffc0bafc <_Heap_Walk+0x704>
- 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;
ffc0ba88: 81 26 00 04 lwz r9,4(r6)
ffc0ba8c: 55 29 00 3c rlwinm r9,r9,0,0,30
block = next_block;
} while ( block != first_block );
return true;
}
ffc0ba90: 7d 26 4a 14 add r9,r6,r9
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;
ffc0ba94: 81 29 00 04 lwz r9,4(r9)
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
ffc0ba98: 71 27 00 01 andi. r7,r9,1
ffc0ba9c: 40 82 00 38 bne- ffc0bad4 <_Heap_Walk+0x6dc>
);
return false;
}
if ( free_block->prev != prev_block ) {
ffc0baa0: 80 e6 00 0c lwz r7,12(r6)
ffc0baa4: 7f 87 58 00 cmpw cr7,r7,r11
ffc0baa8: 41 9e ff a8 beq+ cr7,ffc0ba50 <_Heap_Walk+0x658>
(*printer)(
ffc0baac: 80 01 00 18 lwz r0,24(r1)
ffc0bab0: 3c a0 ff c2 lis r5,-62
ffc0bab4: 7f 23 cb 78 mr r3,r25
ffc0bab8: 38 80 00 01 li r4,1
ffc0babc: 7c 09 03 a6 mtctr r0
ffc0bac0: 38 a5 bb a0 addi r5,r5,-17504
ffc0bac4: 4c c6 31 82 crclr 4*cr1+eq
ffc0bac8: 4e 80 04 21 bctrl
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
ffc0bacc: 38 60 00 00 li r3,0
ffc0bad0: 4b ff f9 bc b ffc0b48c <_Heap_Walk+0x94>
return false;
}
if ( _Heap_Is_used( free_block ) ) {
(*printer)(
ffc0bad4: 80 01 00 18 lwz r0,24(r1)
ffc0bad8: 3c a0 ff c2 lis r5,-62
ffc0badc: 7f 23 cb 78 mr r3,r25
ffc0bae0: 38 80 00 01 li r4,1
ffc0bae4: 7c 09 03 a6 mtctr r0
ffc0bae8: 38 a5 bb 84 addi r5,r5,-17532
ffc0baec: 4c c6 31 82 crclr 4*cr1+eq
ffc0baf0: 4e 80 04 21 bctrl
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
ffc0baf4: 38 60 00 00 li r3,0
ffc0baf8: 4b ff f9 94 b ffc0b48c <_Heap_Walk+0x94>
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
ffc0bafc: 80 01 00 18 lwz r0,24(r1)
ffc0bb00: 3c a0 ff c2 lis r5,-62
ffc0bb04: 7f 23 cb 78 mr r3,r25
ffc0bb08: 38 80 00 01 li r4,1
ffc0bb0c: 7c 09 03 a6 mtctr r0
ffc0bb10: 38 a5 bb 54 addi r5,r5,-17580
ffc0bb14: 4c c6 31 82 crclr 4*cr1+eq
ffc0bb18: 4e 80 04 21 bctrl
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
ffc0bb1c: 38 60 00 00 li r3,0
ffc0bb20: 4b ff f9 6c b ffc0b48c <_Heap_Walk+0x94>
ffc0b2f8 <_Heap_Walk_print>:
static void _Heap_Walk_print( int source, bool error, const char *fmt, ... )
{
ffc0b2f8: 94 21 ff 88 stwu r1,-120(r1)
ffc0b2fc: 7c 08 02 a6 mflr r0
ffc0b300: 93 e1 00 74 stw r31,116(r1)
ffc0b304: 90 01 00 7c stw r0,124(r1)
ffc0b308: 7c 60 1b 78 mr r0,r3
ffc0b30c: 90 c1 00 1c stw r6,28(r1)
ffc0b310: 90 e1 00 20 stw r7,32(r1)
ffc0b314: 91 01 00 24 stw r8,36(r1)
ffc0b318: 91 21 00 28 stw r9,40(r1)
ffc0b31c: 91 41 00 2c stw r10,44(r1)
ffc0b320: 40 86 00 24 bne- cr1,ffc0b344 <_Heap_Walk_print+0x4c> <== ALWAYS TAKEN
ffc0b324: d8 21 00 30 stfd f1,48(r1) <== NOT EXECUTED
ffc0b328: d8 41 00 38 stfd f2,56(r1) <== NOT EXECUTED
ffc0b32c: d8 61 00 40 stfd f3,64(r1) <== NOT EXECUTED
ffc0b330: d8 81 00 48 stfd f4,72(r1) <== NOT EXECUTED
ffc0b334: d8 a1 00 50 stfd f5,80(r1) <== NOT EXECUTED
ffc0b338: d8 c1 00 58 stfd f6,88(r1) <== NOT EXECUTED
ffc0b33c: d8 e1 00 60 stfd f7,96(r1) <== NOT EXECUTED
ffc0b340: d9 01 00 68 stfd f8,104(r1) <== NOT EXECUTED
va_list ap;
if ( error ) {
ffc0b344: 2f 84 00 00 cmpwi cr7,r4,0
{
/* Do nothing */
}
static void _Heap_Walk_print( int source, bool error, const char *fmt, ... )
{
ffc0b348: 7c bf 2b 78 mr r31,r5
va_list ap;
if ( error ) {
ffc0b34c: 40 9e 00 58 bne- cr7,ffc0b3a4 <_Heap_Walk_print+0xac>
printk( "FAIL[%d]: ", source );
} else {
printk( "PASS[%d]: ", source );
ffc0b350: 3c 60 ff c2 lis r3,-62
ffc0b354: 7c 04 03 78 mr r4,r0
ffc0b358: 38 63 b9 58 addi r3,r3,-18088
ffc0b35c: 4c c6 31 82 crclr 4*cr1+eq
ffc0b360: 4b ff b1 d9 bl ffc06538 <printk>
}
va_start( ap, fmt );
ffc0b364: 38 00 00 03 li r0,3
ffc0b368: 98 01 00 08 stb r0,8(r1)
ffc0b36c: 38 00 00 00 li r0,0
vprintk( fmt, ap );
ffc0b370: 7f e3 fb 78 mr r3,r31
printk( "FAIL[%d]: ", source );
} else {
printk( "PASS[%d]: ", source );
}
va_start( ap, fmt );
ffc0b374: 98 01 00 09 stb r0,9(r1)
ffc0b378: 38 01 00 80 addi r0,r1,128
vprintk( fmt, ap );
ffc0b37c: 38 81 00 08 addi r4,r1,8
printk( "FAIL[%d]: ", source );
} else {
printk( "PASS[%d]: ", source );
}
va_start( ap, fmt );
ffc0b380: 90 01 00 0c stw r0,12(r1)
ffc0b384: 38 01 00 10 addi r0,r1,16
ffc0b388: 90 01 00 10 stw r0,16(r1)
vprintk( fmt, ap );
ffc0b38c: 4b ff d5 39 bl ffc088c4 <vprintk>
va_end( ap );
}
ffc0b390: 80 01 00 7c lwz r0,124(r1)
ffc0b394: 83 e1 00 74 lwz r31,116(r1)
ffc0b398: 38 21 00 78 addi r1,r1,120
ffc0b39c: 7c 08 03 a6 mtlr r0
ffc0b3a0: 4e 80 00 20 blr
static void _Heap_Walk_print( int source, bool error, const char *fmt, ... )
{
va_list ap;
if ( error ) {
printk( "FAIL[%d]: ", source );
ffc0b3a4: 3c 60 ff c2 lis r3,-62
ffc0b3a8: 7c 04 03 78 mr r4,r0
ffc0b3ac: 38 63 b9 4c addi r3,r3,-18100
ffc0b3b0: 4c c6 31 82 crclr 4*cr1+eq
ffc0b3b4: 4b ff b1 85 bl ffc06538 <printk>
} else {
printk( "PASS[%d]: ", source );
}
va_start( ap, fmt );
ffc0b3b8: 38 00 00 03 li r0,3
ffc0b3bc: 98 01 00 08 stb r0,8(r1)
ffc0b3c0: 38 00 00 00 li r0,0
vprintk( fmt, ap );
ffc0b3c4: 7f e3 fb 78 mr r3,r31
printk( "FAIL[%d]: ", source );
} else {
printk( "PASS[%d]: ", source );
}
va_start( ap, fmt );
ffc0b3c8: 98 01 00 09 stb r0,9(r1)
ffc0b3cc: 38 01 00 80 addi r0,r1,128
vprintk( fmt, ap );
ffc0b3d0: 38 81 00 08 addi r4,r1,8
printk( "FAIL[%d]: ", source );
} else {
printk( "PASS[%d]: ", source );
}
va_start( ap, fmt );
ffc0b3d4: 90 01 00 0c stw r0,12(r1)
ffc0b3d8: 38 01 00 10 addi r0,r1,16
ffc0b3dc: 90 01 00 10 stw r0,16(r1)
vprintk( fmt, ap );
ffc0b3e0: 4b ff d4 e5 bl ffc088c4 <vprintk>
va_end( ap );
}
ffc0b3e4: 80 01 00 7c lwz r0,124(r1)
ffc0b3e8: 83 e1 00 74 lwz r31,116(r1)
ffc0b3ec: 38 21 00 78 addi r1,r1,120
ffc0b3f0: 7c 08 03 a6 mtlr r0
ffc0b3f4: 4e 80 00 20 blr
ffc09e6c <_IO_Initialize_all_drivers>:
*
* Output Parameters: NONE
*/
void _IO_Initialize_all_drivers( void )
{
ffc09e6c: 94 21 ff f0 stwu r1,-16(r1)
ffc09e70: 7c 08 02 a6 mflr r0
ffc09e74: 93 c1 00 08 stw r30,8(r1)
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
ffc09e78: 3f c0 00 00 lis r30,0
*
* Output Parameters: NONE
*/
void _IO_Initialize_all_drivers( void )
{
ffc09e7c: 90 01 00 14 stw r0,20(r1)
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
ffc09e80: 80 1e 28 58 lwz r0,10328(r30)
*
* Output Parameters: NONE
*/
void _IO_Initialize_all_drivers( void )
{
ffc09e84: 93 e1 00 0c stw r31,12(r1)
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
ffc09e88: 2f 80 00 00 cmpwi cr7,r0,0
ffc09e8c: 41 9e 00 2c beq- cr7,ffc09eb8 <_IO_Initialize_all_drivers+0x4c><== NEVER TAKEN
ffc09e90: 3b e0 00 00 li r31,0
ffc09e94: 3b de 28 58 addi r30,r30,10328
(void) rtems_io_initialize( major, 0, NULL );
ffc09e98: 7f e3 fb 78 mr r3,r31
ffc09e9c: 38 80 00 00 li r4,0
ffc09ea0: 38 a0 00 00 li r5,0
ffc09ea4: 48 00 6e 35 bl ffc10cd8 <rtems_io_initialize>
void _IO_Initialize_all_drivers( void )
{
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
ffc09ea8: 80 1e 00 00 lwz r0,0(r30)
ffc09eac: 3b ff 00 01 addi r31,r31,1
ffc09eb0: 7f 80 f8 40 cmplw cr7,r0,r31
ffc09eb4: 41 9d ff e4 bgt+ cr7,ffc09e98 <_IO_Initialize_all_drivers+0x2c>
(void) rtems_io_initialize( major, 0, NULL );
}
ffc09eb8: 80 01 00 14 lwz r0,20(r1)
ffc09ebc: 83 c1 00 08 lwz r30,8(r1)
ffc09ec0: 7c 08 03 a6 mtlr r0
ffc09ec4: 83 e1 00 0c lwz r31,12(r1)
ffc09ec8: 38 21 00 10 addi r1,r1,16
ffc09ecc: 4e 80 00 20 blr
ffc09d5c <_IO_Manager_initialization>:
* workspace.
*
*/
void _IO_Manager_initialization(void)
{
ffc09d5c: 94 21 ff e0 stwu r1,-32(r1)
ffc09d60: 7c 08 02 a6 mflr r0
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;
ffc09d64: 3d 20 00 00 lis r9,0
* workspace.
*
*/
void _IO_Manager_initialization(void)
{
ffc09d68: 90 01 00 24 stw r0,36(r1)
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;
ffc09d6c: 39 29 20 04 addi r9,r9,8196
* workspace.
*
*/
void _IO_Manager_initialization(void)
{
ffc09d70: 93 a1 00 14 stw r29,20(r1)
ffc09d74: 93 c1 00 18 stw r30,24(r1)
uint32_t drivers_in_table;
uint32_t number_of_drivers;
driver_table = Configuration.Device_driver_table;
drivers_in_table = Configuration.number_of_device_drivers;
number_of_drivers = Configuration.maximum_drivers;
ffc09d78: 83 a9 00 2c lwz r29,44(r9)
rtems_driver_address_table *driver_table;
uint32_t drivers_in_table;
uint32_t number_of_drivers;
driver_table = Configuration.Device_driver_table;
drivers_in_table = Configuration.number_of_device_drivers;
ffc09d7c: 83 c9 00 30 lwz r30,48(r9)
* workspace.
*
*/
void _IO_Manager_initialization(void)
{
ffc09d80: 93 e1 00 1c stw r31,28(r1)
/*
* 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 )
ffc09d84: 7f 9e e8 40 cmplw cr7,r30,r29
* workspace.
*
*/
void _IO_Manager_initialization(void)
{
ffc09d88: 93 61 00 0c stw r27,12(r1)
ffc09d8c: 93 81 00 10 stw r28,16(r1)
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;
ffc09d90: 83 e9 00 34 lwz r31,52(r9)
/*
* 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 )
ffc09d94: 40 9c 00 a4 bge- cr7,ffc09e38 <_IO_Manager_initialization+0xdc>
* 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 )
ffc09d98: 1f 7d 00 18 mulli r27,r29,24
* 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(
ffc09d9c: 7f 63 db 78 mr r3,r27
ffc09da0: 48 00 3e b1 bl ffc0dc50 <_Workspace_Allocate_or_fatal_error>
/*
* 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 *)
ffc09da4: 3f 80 00 00 lis r28,0
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
ffc09da8: 3d 20 00 00 lis r9,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 *)
ffc09dac: 90 7c 28 5c stw r3,10332(r28)
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
memset(
ffc09db0: 38 80 00 00 li r4,0
ffc09db4: 7f 65 db 78 mr r5,r27
_IO_Driver_address_table = (rtems_driver_address_table *)
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
ffc09db8: 93 a9 28 58 stw r29,10328(r9)
memset(
ffc09dbc: 48 00 ad f1 bl ffc14bac <memset>
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
ffc09dc0: 2f 9e 00 00 cmpwi cr7,r30,0
ffc09dc4: 41 9e 00 50 beq- cr7,ffc09e14 <_IO_Manager_initialization+0xb8><== NEVER TAKEN
ffc09dc8: 7f c9 03 a6 mtctr r30
ffc09dcc: 81 1c 28 5c lwz r8,10332(r28)
ffc09dd0: 39 40 00 00 li r10,0
_IO_Driver_address_table[index] = driver_table[index];
ffc09dd4: 7f e9 fb 78 mr r9,r31
ffc09dd8: 7c a9 50 6e lwzux r5,r9,r10
ffc09ddc: 7d 68 52 14 add r11,r8,r10
ffc09de0: 80 e9 00 08 lwz r7,8(r9)
ffc09de4: 80 09 00 0c lwz r0,12(r9)
ffc09de8: 80 c9 00 04 lwz r6,4(r9)
ffc09dec: 7c a8 51 2e stwx r5,r8,r10
memset(
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
ffc09df0: 39 4a 00 18 addi r10,r10,24
_IO_Driver_address_table[index] = driver_table[index];
ffc09df4: 90 cb 00 04 stw r6,4(r11)
ffc09df8: 90 eb 00 08 stw r7,8(r11)
ffc09dfc: 90 0b 00 0c stw r0,12(r11)
ffc09e00: 80 e9 00 10 lwz r7,16(r9)
ffc09e04: 80 09 00 14 lwz r0,20(r9)
ffc09e08: 90 eb 00 10 stw r7,16(r11)
ffc09e0c: 90 0b 00 14 stw r0,20(r11)
memset(
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
ffc09e10: 42 00 ff c4 bdnz+ ffc09dd4 <_IO_Manager_initialization+0x78>
_IO_Driver_address_table[index] = driver_table[index];
}
ffc09e14: 80 01 00 24 lwz r0,36(r1)
ffc09e18: 83 61 00 0c lwz r27,12(r1)
ffc09e1c: 7c 08 03 a6 mtlr r0
ffc09e20: 83 81 00 10 lwz r28,16(r1)
ffc09e24: 83 a1 00 14 lwz r29,20(r1)
ffc09e28: 83 c1 00 18 lwz r30,24(r1)
ffc09e2c: 83 e1 00 1c lwz r31,28(r1)
ffc09e30: 38 21 00 20 addi r1,r1,32
ffc09e34: 4e 80 00 20 blr
ffc09e38: 80 01 00 24 lwz r0,36(r1)
* 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;
ffc09e3c: 3d 20 00 00 lis r9,0
ffc09e40: 93 e9 28 5c stw r31,10332(r9)
_IO_Number_of_drivers = number_of_drivers;
ffc09e44: 3d 20 00 00 lis r9,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];
}
ffc09e48: 7c 08 03 a6 mtlr r0
* 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;
_IO_Number_of_drivers = number_of_drivers;
ffc09e4c: 93 c9 28 58 stw r30,10328(r9)
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
_IO_Driver_address_table[index] = driver_table[index];
}
ffc09e50: 83 61 00 0c lwz r27,12(r1)
ffc09e54: 83 81 00 10 lwz r28,16(r1)
ffc09e58: 83 a1 00 14 lwz r29,20(r1)
ffc09e5c: 83 c1 00 18 lwz r30,24(r1)
ffc09e60: 83 e1 00 1c lwz r31,28(r1)
ffc09e64: 38 21 00 20 addi r1,r1,32
ffc09e68: 4e 80 00 20 blr
ffc0adc0 <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
ffc0adc0: 94 21 ff f0 stwu r1,-16(r1)
ffc0adc4: 7c 08 02 a6 mflr r0
_Internal_errors_What_happened.the_source = the_source;
ffc0adc8: 3d 60 00 00 lis r11,0
ffc0adcc: 39 2b 2d 50 addi r9,r11,11600
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
ffc0add0: 90 01 00 14 stw r0,20(r1)
ffc0add4: 93 e1 00 0c stw r31,12(r1)
ffc0add8: 7c bf 2b 78 mr r31,r5
_Internal_errors_What_happened.the_source = the_source;
_Internal_errors_What_happened.is_internal = is_internal;
ffc0addc: 98 89 00 04 stb r4,4(r9)
_Internal_errors_What_happened.the_error = the_error;
ffc0ade0: 90 a9 00 08 stw r5,8(r9)
bool is_internal,
Internal_errors_t the_error
)
{
_Internal_errors_What_happened.the_source = the_source;
ffc0ade4: 90 6b 2d 50 stw r3,11600(r11)
_Internal_errors_What_happened.is_internal = is_internal;
_Internal_errors_What_happened.the_error = the_error;
_User_extensions_Fatal( the_source, is_internal, the_error );
ffc0ade8: 48 00 27 41 bl ffc0d528 <_User_extensions_Fatal>
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
ffc0adec: 38 00 00 05 li r0,5
ffc0adf0: 3d 20 00 00 lis r9,0
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
ffc0adf4: 7f e3 fb 78 mr r3,r31
ffc0adf8: 90 09 28 48 stw r0,10312(r9)
ffc0adfc: 4b ff 91 1d bl ffc03f18 <_BSP_Fatal_error>
ffc0ae00: 48 00 00 00 b ffc0ae00 <_Internal_error_Occurred+0x40><== NOT EXECUTED
ffc0ae18 <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
ffc0ae18: 94 21 ff f0 stwu r1,-16(r1)
ffc0ae1c: 7c 08 02 a6 mflr r0
ffc0ae20: 90 01 00 14 stw r0,20(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 )
ffc0ae24: 80 03 00 18 lwz r0,24(r3)
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
ffc0ae28: 93 e1 00 0c stw r31,12(r1)
ffc0ae2c: 7c 7f 1b 78 mr r31,r3
* 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 )
ffc0ae30: 2f 80 00 00 cmpwi cr7,r0,0
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
ffc0ae34: 93 c1 00 08 stw r30,8(r1)
* still attempts to create the object, the information block
* should be all zeroed out because it is in the BSS. So let's
* check that code for this manager is even present.
*/
if ( information->size == 0 )
return NULL;
ffc0ae38: 38 60 00 00 li r3,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 )
ffc0ae3c: 41 9e 00 58 beq- cr7,ffc0ae94 <_Objects_Allocate+0x7c> <== 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 );
ffc0ae40: 3b df 00 20 addi r30,r31,32
ffc0ae44: 7f c3 f3 78 mr r3,r30
ffc0ae48: 4b ff f3 fd bl ffc0a244 <_Chain_Get>
if ( information->auto_extend ) {
ffc0ae4c: 88 1f 00 12 lbz r0,18(r31)
ffc0ae50: 2f 80 00 00 cmpwi cr7,r0,0
ffc0ae54: 41 9e 00 40 beq- cr7,ffc0ae94 <_Objects_Allocate+0x7c>
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
ffc0ae58: 2f 83 00 00 cmpwi cr7,r3,0
ffc0ae5c: 41 9e 00 50 beq- cr7,ffc0aeac <_Objects_Allocate+0x94>
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
ffc0ae60: a1 63 00 0a lhz r11,10(r3)
ffc0ae64: a0 1f 00 0a lhz r0,10(r31)
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
ffc0ae68: a1 3f 00 14 lhz r9,20(r31)
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
ffc0ae6c: 7c 00 58 50 subf r0,r0,r11
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
information->inactive_per_block[ block ]--;
information->inactive--;
ffc0ae70: a1 7f 00 2c lhz r11,44(r31)
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
ffc0ae74: 7c 00 4b 96 divwu r0,r0,r9
information->inactive_per_block[ block ]--;
ffc0ae78: 81 3f 00 30 lwz r9,48(r31)
ffc0ae7c: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc0ae80: 7d 49 00 2e lwzx r10,r9,r0
information->inactive--;
ffc0ae84: 39 6b ff ff addi r11,r11,-1
block = (uint32_t) _Objects_Get_index( the_object->id ) -
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
information->inactive_per_block[ block ]--;
ffc0ae88: 39 4a ff ff addi r10,r10,-1
ffc0ae8c: 7d 49 01 2e stwx r10,r9,r0
information->inactive--;
ffc0ae90: b1 7f 00 2c sth r11,44(r31)
);
}
#endif
return the_object;
}
ffc0ae94: 80 01 00 14 lwz r0,20(r1)
ffc0ae98: 83 c1 00 08 lwz r30,8(r1)
ffc0ae9c: 7c 08 03 a6 mtlr r0
ffc0aea0: 83 e1 00 0c lwz r31,12(r1)
ffc0aea4: 38 21 00 10 addi r1,r1,16
ffc0aea8: 4e 80 00 20 blr
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
_Objects_Extend_information( information );
ffc0aeac: 7f e3 fb 78 mr r3,r31
ffc0aeb0: 48 00 00 4d bl ffc0aefc <_Objects_Extend_information>
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
ffc0aeb4: 7f c3 f3 78 mr r3,r30
ffc0aeb8: 4b ff f3 8d bl ffc0a244 <_Chain_Get>
}
if ( the_object ) {
ffc0aebc: 2c 03 00 00 cmpwi r3,0
ffc0aec0: 41 82 ff d4 beq+ ffc0ae94 <_Objects_Allocate+0x7c>
ffc0aec4: 4b ff ff 9c b ffc0ae60 <_Objects_Allocate+0x48>
ffc0aefc <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
ffc0aefc: 94 21 ff c0 stwu r1,-64(r1)
ffc0af00: 7c 08 02 a6 mflr r0
ffc0af04: 90 01 00 44 stw r0,68(r1)
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
ffc0af08: 81 23 00 34 lwz r9,52(r3)
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
ffc0af0c: 93 61 00 2c stw r27,44(r1)
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
ffc0af10: 2f 89 00 00 cmpwi cr7,r9,0
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
ffc0af14: 93 81 00 30 stw r28,48(r1)
ffc0af18: 93 e1 00 3c stw r31,60(r1)
ffc0af1c: 7c 7f 1b 78 mr r31,r3
ffc0af20: 92 c1 00 18 stw r22,24(r1)
ffc0af24: 92 e1 00 1c stw r23,28(r1)
ffc0af28: 93 01 00 20 stw r24,32(r1)
ffc0af2c: 93 21 00 24 stw r25,36(r1)
ffc0af30: 93 41 00 28 stw r26,40(r1)
ffc0af34: 93 a1 00 34 stw r29,52(r1)
ffc0af38: 93 c1 00 38 stw r30,56(r1)
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
ffc0af3c: a3 83 00 0a lhz r28,10(r3)
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
ffc0af40: a3 63 00 10 lhz r27,16(r3)
ffc0af44: 41 9e 02 80 beq- cr7,ffc0b1c4 <_Objects_Extend_information+0x2c8>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
ffc0af48: a1 63 00 14 lhz r11,20(r3)
ffc0af4c: 7e db 5b 96 divwu r22,r27,r11
for ( ; block < block_count; block++ ) {
ffc0af50: 2f 96 00 00 cmpwi cr7,r22,0
ffc0af54: 41 9e 02 88 beq- cr7,ffc0b1dc <_Objects_Extend_information+0x2e0><== NEVER TAKEN
if ( information->object_blocks[ block ] == NULL ) {
ffc0af58: 80 09 00 00 lwz r0,0(r9)
ffc0af5c: 7d 6a 5b 78 mr r10,r11
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
ffc0af60: 7f 9e e3 78 mr r30,r28
index_base = minimum_index;
block = 0;
ffc0af64: 7e c9 03 a6 mtctr r22
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
ffc0af68: 2f 80 00 00 cmpwi cr7,r0,0
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
ffc0af6c: 3b a0 00 00 li r29,0
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
ffc0af70: 40 be 00 14 bne+ cr7,ffc0af84 <_Objects_Extend_information+0x88><== ALWAYS TAKEN
ffc0af74: 48 00 02 7c b ffc0b1f0 <_Objects_Extend_information+0x2f4><== NOT EXECUTED
ffc0af78: 84 09 00 04 lwzu r0,4(r9)
ffc0af7c: 2f 80 00 00 cmpwi cr7,r0,0
ffc0af80: 41 9e 01 f4 beq- cr7,ffc0b174 <_Objects_Extend_information+0x278>
do_extend = false;
break;
} else
index_base += information->allocation_size;
ffc0af84: 7f de 5a 14 add r30,r30,r11
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
ffc0af88: 3b bd 00 01 addi r29,r29,1
ffc0af8c: 42 00 ff ec bdnz+ ffc0af78 <_Objects_Extend_information+0x7c>
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
ffc0af90: 3b 20 00 01 li r25,1
} else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
ffc0af94: 7f 7b 52 14 add r27,r27,r10
/*
* We need to limit the number of objects to the maximum number
* representable in the index portion of the object Id. In the
* case of 16-bit Ids, this is only 256 object instances.
*/
if ( maximum > OBJECTS_ID_FINAL_INDEX ) {
ffc0af98: 2b 9b ff ff cmplwi cr7,r27,65535
ffc0af9c: 41 9d 01 a0 bgt- cr7,ffc0b13c <_Objects_Extend_information+0x240>
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
if ( information->auto_extend ) {
ffc0afa0: 88 1f 00 12 lbz r0,18(r31)
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
ffc0afa4: 80 7f 00 18 lwz r3,24(r31)
if ( information->auto_extend ) {
ffc0afa8: 2f 80 00 00 cmpwi cr7,r0,0
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
ffc0afac: 7c 6a 19 d6 mullw r3,r10,r3
if ( information->auto_extend ) {
ffc0afb0: 41 9e 01 cc beq- cr7,ffc0b17c <_Objects_Extend_information+0x280>
new_object_block = _Workspace_Allocate( block_size );
ffc0afb4: 48 00 2c 3d bl ffc0dbf0 <_Workspace_Allocate>
if ( !new_object_block )
ffc0afb8: 7c 7a 1b 79 mr. r26,r3
ffc0afbc: 41 82 01 80 beq- ffc0b13c <_Objects_Extend_information+0x240>
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
ffc0afc0: 2f 99 00 00 cmpwi cr7,r25,0
ffc0afc4: 41 9e 00 f4 beq- cr7,ffc0b0b8 <_Objects_Extend_information+0x1bc>
*/
/*
* Up the block count and maximum
*/
block_count++;
ffc0afc8: 3a f6 00 01 addi r23,r22,1
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
ffc0afcc: 1c 77 00 03 mulli r3,r23,3
((maximum + minimum_index) * sizeof(Objects_Control *));
ffc0afd0: 7c 7b 1a 14 add r3,r27,r3
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
ffc0afd4: 7c 63 e2 14 add r3,r3,r28
((maximum + minimum_index) * sizeof(Objects_Control *));
object_blocks = (void**) _Workspace_Allocate( block_size );
ffc0afd8: 54 63 10 3a rlwinm r3,r3,2,0,29
ffc0afdc: 48 00 2c 15 bl ffc0dbf0 <_Workspace_Allocate>
if ( !object_blocks ) {
ffc0afe0: 7c 78 1b 79 mr. r24,r3
ffc0afe4: 41 82 02 18 beq- ffc0b1fc <_Objects_Extend_information+0x300>
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
ffc0afe8: a0 1f 00 10 lhz r0,16(r31)
}
/*
* Break the block into the various sections.
*/
inactive_per_block = (uint32_t *) _Addresses_Add_offset(
ffc0afec: 56 f7 10 3a rlwinm r23,r23,2,0,29
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
ffc0aff0: 7f 38 ba 14 add r25,r24,r23
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
ffc0aff4: 7f 9c 00 40 cmplw cr7,r28,r0
ffc0aff8: 7e f9 ba 14 add r23,r25,r23
ffc0affc: 41 9c 01 8c blt- cr7,ffc0b188 <_Objects_Extend_information+0x28c>
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
ffc0b000: 2f 9c 00 00 cmpwi cr7,r28,0
local_table[ index ] = NULL;
ffc0b004: 7f 89 03 a6 mtctr r28
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
ffc0b008: 39 37 ff fc addi r9,r23,-4
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
local_table[ index ] = NULL;
ffc0b00c: 38 00 00 00 li r0,0
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
ffc0b010: 41 9e 00 0c beq- cr7,ffc0b01c <_Objects_Extend_information+0x120><== NEVER TAKEN
local_table[ index ] = NULL;
ffc0b014: 94 09 00 04 stwu r0,4(r9)
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
ffc0b018: 42 00 ff fc bdnz+ ffc0b014 <_Objects_Extend_information+0x118>
ffc0b01c: 56 d6 10 3a rlwinm r22,r22,2,0,29
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
ffc0b020: a1 7f 00 14 lhz r11,20(r31)
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
ffc0b024: 38 00 00 00 li r0,0
ffc0b028: 7c 18 b1 2e stwx r0,r24,r22
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
ffc0b02c: 7d 7e 5a 14 add r11,r30,r11
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
ffc0b030: 7f 9e 58 40 cmplw cr7,r30,r11
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
ffc0b034: 7c 19 b1 2e stwx r0,r25,r22
for ( index=index_base ;
ffc0b038: 40 9c 00 30 bge- cr7,ffc0b068 <_Objects_Extend_information+0x16c><== NEVER TAKEN
ffc0b03c: 38 1e 00 01 addi r0,r30,1
ffc0b040: 7f 80 58 40 cmplw cr7,r0,r11
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
ffc0b044: 57 c9 10 3a rlwinm r9,r30,2,0,29
ffc0b048: 39 29 ff fc addi r9,r9,-4
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
ffc0b04c: 7d 7e 58 50 subf r11,r30,r11
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
ffc0b050: 7d 29 ba 14 add r9,r9,r23
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
ffc0b054: 7d 69 03 a6 mtctr r11
ffc0b058: 38 00 00 00 li r0,0
ffc0b05c: 41 9d 01 ac bgt- cr7,ffc0b208 <_Objects_Extend_information+0x30c><== NEVER TAKEN
ffc0b060: 94 09 00 04 stwu r0,4(r9)
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
ffc0b064: 42 00 ff fc bdnz+ ffc0b060 <_Objects_Extend_information+0x164>
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0b068: 7c 00 00 a6 mfmsr r0
ffc0b06c: 7d 30 42 a6 mfsprg r9,0
ffc0b070: 7c 09 48 78 andc r9,r0,r9
ffc0b074: 7d 20 01 24 mtmsr r9
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
ffc0b078: 81 7f 00 00 lwz r11,0(r31)
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = (Objects_Maximum) maximum;
ffc0b07c: 57 7b 04 3e clrlwi r27,r27,16
information->maximum_id = _Objects_Build_id(
ffc0b080: a1 3f 00 04 lhz r9,4(r31)
ffc0b084: 55 6b c0 0e rlwinm r11,r11,24,0,7
local_table[ index ] = NULL;
}
_ISR_Disable( level );
old_tables = information->object_blocks;
ffc0b088: 80 7f 00 34 lwz r3,52(r31)
ffc0b08c: 65 6b 00 01 oris r11,r11,1
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
ffc0b090: 93 3f 00 30 stw r25,48(r31)
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
ffc0b094: 55 29 d8 08 rlwinm r9,r9,27,0,4
ffc0b098: 7d 69 4b 78 or r9,r11,r9
_ISR_Disable( level );
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
ffc0b09c: 93 1f 00 34 stw r24,52(r31)
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
ffc0b0a0: 7d 29 db 78 or r9,r9,r27
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
ffc0b0a4: 92 ff 00 1c stw r23,28(r31)
information->maximum = (Objects_Maximum) maximum;
ffc0b0a8: b3 7f 00 10 sth r27,16(r31)
information->maximum_id = _Objects_Build_id(
ffc0b0ac: 91 3f 00 0c stw r9,12(r31)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0b0b0: 7c 00 01 24 mtmsr r0
information->maximum
);
_ISR_Enable( level );
_Workspace_Free( old_tables );
ffc0b0b4: 48 00 2b 71 bl ffc0dc24 <_Workspace_Free>
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
ffc0b0b8: 81 3f 00 34 lwz r9,52(r31)
ffc0b0bc: 57 bd 10 3a rlwinm r29,r29,2,0,29
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
ffc0b0c0: a0 bf 00 14 lhz r5,20(r31)
ffc0b0c4: 38 61 00 08 addi r3,r1,8
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
ffc0b0c8: 7f 49 e9 2e stwx r26,r9,r29
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
ffc0b0cc: 3b 9f 00 20 addi r28,r31,32
information->object_blocks[ block ] = new_object_block;
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
ffc0b0d0: 81 3f 00 34 lwz r9,52(r31)
ffc0b0d4: 80 df 00 18 lwz r6,24(r31)
ffc0b0d8: 7c 89 e8 2e lwzx r4,r9,r29
ffc0b0dc: 48 00 5c 6d bl ffc10d48 <_Chain_Initialize>
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
ffc0b0e0: 48 00 00 2c b ffc0b10c <_Objects_Extend_information+0x210>
ffc0b0e4: 81 7f 00 00 lwz r11,0(r31)
the_object->id = _Objects_Build_id(
ffc0b0e8: a0 1f 00 04 lhz r0,4(r31)
ffc0b0ec: 55 6b c0 0e rlwinm r11,r11,24,0,7
ffc0b0f0: 65 6b 00 01 oris r11,r11,1
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
ffc0b0f4: 54 00 d8 08 rlwinm r0,r0,27,0,4
ffc0b0f8: 7d 60 03 78 or r0,r11,r0
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
ffc0b0fc: 7c 00 f3 78 or r0,r0,r30
ffc0b100: 90 09 00 08 stw r0,8(r9)
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
ffc0b104: 3b de 00 01 addi r30,r30,1
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
ffc0b108: 4b ff f0 e5 bl ffc0a1ec <_Chain_Append>
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
ffc0b10c: 38 61 00 08 addi r3,r1,8
ffc0b110: 4b ff f1 35 bl ffc0a244 <_Chain_Get>
ffc0b114: 7c 69 1b 79 mr. r9,r3
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
ffc0b118: 7f 83 e3 78 mr r3,r28
ffc0b11c: 7d 24 4b 78 mr r4,r9
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
ffc0b120: 40 82 ff c4 bne+ ffc0b0e4 <_Objects_Extend_information+0x1e8>
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
ffc0b124: a1 3f 00 2c lhz r9,44(r31)
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
ffc0b128: a0 1f 00 14 lhz r0,20(r31)
ffc0b12c: 81 7f 00 30 lwz r11,48(r31)
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
ffc0b130: 7d 20 4a 14 add r9,r0,r9
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
ffc0b134: 7c 0b e9 2e stwx r0,r11,r29
information->inactive =
ffc0b138: b1 3f 00 2c sth r9,44(r31)
(Objects_Maximum)(information->inactive + information->allocation_size);
}
ffc0b13c: 80 01 00 44 lwz r0,68(r1)
ffc0b140: 82 c1 00 18 lwz r22,24(r1)
ffc0b144: 7c 08 03 a6 mtlr r0
ffc0b148: 82 e1 00 1c lwz r23,28(r1)
ffc0b14c: 83 01 00 20 lwz r24,32(r1)
ffc0b150: 83 21 00 24 lwz r25,36(r1)
ffc0b154: 83 41 00 28 lwz r26,40(r1)
ffc0b158: 83 61 00 2c lwz r27,44(r1)
ffc0b15c: 83 81 00 30 lwz r28,48(r1)
ffc0b160: 83 a1 00 34 lwz r29,52(r1)
ffc0b164: 83 c1 00 38 lwz r30,56(r1)
ffc0b168: 83 e1 00 3c lwz r31,60(r1)
ffc0b16c: 38 21 00 40 addi r1,r1,64
ffc0b170: 4e 80 00 20 blr
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
do_extend = false;
ffc0b174: 3b 20 00 00 li r25,0
ffc0b178: 4b ff fe 1c b ffc0af94 <_Objects_Extend_information+0x98>
if ( information->auto_extend ) {
new_object_block = _Workspace_Allocate( block_size );
if ( !new_object_block )
return;
} else {
new_object_block = _Workspace_Allocate_or_fatal_error( block_size );
ffc0b17c: 48 00 2a d5 bl ffc0dc50 <_Workspace_Allocate_or_fatal_error>
ffc0b180: 7c 7a 1b 78 mr r26,r3
ffc0b184: 4b ff fe 3c b ffc0afc0 <_Objects_Extend_information+0xc4>
* separate parts as size of each block has changed.
*/
memcpy( object_blocks,
information->object_blocks,
block_count * sizeof(void*) );
ffc0b188: 56 d6 10 3a rlwinm r22,r22,2,0,29
/*
* Copy each section of the table over. This has to be performed as
* separate parts as size of each block has changed.
*/
memcpy( object_blocks,
ffc0b18c: 80 9f 00 34 lwz r4,52(r31)
ffc0b190: 7e c5 b3 78 mr r5,r22
ffc0b194: 48 00 99 35 bl ffc14ac8 <memcpy>
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
ffc0b198: 80 9f 00 30 lwz r4,48(r31)
ffc0b19c: 7e c5 b3 78 mr r5,r22
ffc0b1a0: 7f 23 cb 78 mr r3,r25
ffc0b1a4: 48 00 99 25 bl ffc14ac8 <memcpy>
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
ffc0b1a8: a0 bf 00 10 lhz r5,16(r31)
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
ffc0b1ac: 80 9f 00 1c lwz r4,28(r31)
ffc0b1b0: 7e e3 bb 78 mr r3,r23
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
ffc0b1b4: 7c bc 2a 14 add r5,r28,r5
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
ffc0b1b8: 54 a5 10 3a rlwinm r5,r5,2,0,29
ffc0b1bc: 48 00 99 0d bl ffc14ac8 <memcpy>
ffc0b1c0: 4b ff fe 60 b ffc0b020 <_Objects_Extend_information+0x124>
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
ffc0b1c4: a1 43 00 14 lhz r10,20(r3)
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
ffc0b1c8: 7f 9e e3 78 mr r30,r28
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
ffc0b1cc: 3b 20 00 01 li r25,1
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
ffc0b1d0: 3b a0 00 00 li r29,0
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
block_count = 0;
ffc0b1d4: 3a c0 00 00 li r22,0
ffc0b1d8: 4b ff fd bc b ffc0af94 <_Objects_Extend_information+0x98>
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
ffc0b1dc: 7d 6a 5b 78 mr r10,r11 <== NOT EXECUTED
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
ffc0b1e0: 7f 9e e3 78 mr r30,r28 <== NOT EXECUTED
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
ffc0b1e4: 3b 20 00 01 li r25,1 <== NOT EXECUTED
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
ffc0b1e8: 3b a0 00 00 li r29,0 <== NOT EXECUTED
ffc0b1ec: 4b ff fd a8 b ffc0af94 <_Objects_Extend_information+0x98><== NOT EXECUTED
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
do_extend = false;
ffc0b1f0: 3b 20 00 00 li r25,0 <== NOT EXECUTED
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
ffc0b1f4: 3b a0 00 00 li r29,0 <== NOT EXECUTED
ffc0b1f8: 4b ff fd 9c b ffc0af94 <_Objects_Extend_information+0x98><== NOT EXECUTED
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
object_blocks = (void**) _Workspace_Allocate( block_size );
if ( !object_blocks ) {
_Workspace_Free( new_object_block );
ffc0b1fc: 7f 43 d3 78 mr r3,r26
ffc0b200: 48 00 2a 25 bl ffc0dc24 <_Workspace_Free>
return;
ffc0b204: 4b ff ff 38 b ffc0b13c <_Objects_Extend_information+0x240>
ffc0b208: 39 60 00 01 li r11,1 <== NOT EXECUTED
ffc0b20c: 7d 69 03 a6 mtctr r11 <== NOT EXECUTED
ffc0b210: 4b ff fe 50 b ffc0b060 <_Objects_Extend_information+0x164><== NOT EXECUTED
ffc0b300 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
ffc0b300: 94 21 ff e8 stwu r1,-24(r1)
ffc0b304: 7c 08 02 a6 mflr r0
ffc0b308: 93 c1 00 10 stw r30,16(r1)
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
ffc0b30c: 7c 9e 23 79 mr. r30,r4
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
ffc0b310: 93 a1 00 0c stw r29,12(r1)
ffc0b314: 7c 7d 1b 78 mr r29,r3
ffc0b318: 93 e1 00 14 stw r31,20(r1)
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
return NULL;
ffc0b31c: 3b e0 00 00 li r31,0
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
ffc0b320: 90 01 00 1c stw r0,28(r1)
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
ffc0b324: 41 82 00 4c beq- ffc0b370 <_Objects_Get_information+0x70>
/*
* 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 );
ffc0b328: 48 00 60 61 bl ffc11388 <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
ffc0b32c: 2c 03 00 00 cmpwi r3,0
ffc0b330: 41 82 00 40 beq- ffc0b370 <_Objects_Get_information+0x70>
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
ffc0b334: 7f 83 f0 40 cmplw cr7,r3,r30
ffc0b338: 41 9c 00 38 blt- cr7,ffc0b370 <_Objects_Get_information+0x70>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
ffc0b33c: 3d 20 00 00 lis r9,0
ffc0b340: 57 bd 10 3a rlwinm r29,r29,2,0,29
ffc0b344: 39 29 2c 60 addi r9,r9,11360
ffc0b348: 7d 29 e8 2e lwzx r9,r9,r29
ffc0b34c: 2f 89 00 00 cmpwi cr7,r9,0
ffc0b350: 41 9e 00 20 beq- cr7,ffc0b370 <_Objects_Get_information+0x70><== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
ffc0b354: 57 de 10 3a rlwinm r30,r30,2,0,29
ffc0b358: 7f e9 f0 2e lwzx r31,r9,r30
if ( !info )
ffc0b35c: 2f 9f 00 00 cmpwi cr7,r31,0
ffc0b360: 41 9e 00 10 beq- cr7,ffc0b370 <_Objects_Get_information+0x70><== 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 )
ffc0b364: a0 1f 00 10 lhz r0,16(r31)
ffc0b368: 2f 80 00 00 cmpwi cr7,r0,0
ffc0b36c: 41 9e 00 24 beq- cr7,ffc0b390 <_Objects_Get_information+0x90>
return NULL;
#endif
return info;
}
ffc0b370: 80 01 00 1c lwz r0,28(r1)
ffc0b374: 7f e3 fb 78 mr r3,r31
ffc0b378: 83 a1 00 0c lwz r29,12(r1)
ffc0b37c: 7c 08 03 a6 mtlr r0
ffc0b380: 83 c1 00 10 lwz r30,16(r1)
ffc0b384: 83 e1 00 14 lwz r31,20(r1)
ffc0b388: 38 21 00 18 addi r1,r1,24
ffc0b38c: 4e 80 00 20 blr
* Thus we may have 0 local instances and still have a valid object
* pointer.
*/
#if !defined(RTEMS_MULTIPROCESSING)
if ( info->maximum == 0 )
return NULL;
ffc0b390: 3b e0 00 00 li r31,0
ffc0b394: 4b ff ff dc b ffc0b370 <_Objects_Get_information+0x70>
ffc0cfbc <_Objects_Get_name_as_string>:
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
ffc0cfbc: 94 21 ff d8 stwu r1,-40(r1)
ffc0cfc0: 7c 08 02 a6 mflr r0
ffc0cfc4: 93 c1 00 20 stw r30,32(r1)
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
ffc0cfc8: 7c 9e 23 79 mr. r30,r4
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
ffc0cfcc: 93 e1 00 24 stw r31,36(r1)
ffc0cfd0: 7c bf 2b 78 mr r31,r5
ffc0cfd4: 90 01 00 2c stw r0,44(r1)
ffc0cfd8: 93 81 00 18 stw r28,24(r1)
ffc0cfdc: 93 a1 00 1c stw r29,28(r1)
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
ffc0cfe0: 41 82 01 0c beq- ffc0d0ec <_Objects_Get_name_as_string+0x130>
return NULL;
if ( name == NULL )
ffc0cfe4: 2f 85 00 00 cmpwi cr7,r5,0
ffc0cfe8: 41 9e 00 d0 beq- cr7,ffc0d0b8 <_Objects_Get_name_as_string+0xfc>
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
ffc0cfec: 2f 83 00 00 cmpwi cr7,r3,0
ffc0cff0: 7c 7c 1b 78 mr r28,r3
ffc0cff4: 41 9e 00 e8 beq- cr7,ffc0d0dc <_Objects_Get_name_as_string+0x120>
information = _Objects_Get_information_id( tmpId );
ffc0cff8: 7f 83 e3 78 mr r3,r28
ffc0cffc: 4b ff fe 8d bl ffc0ce88 <_Objects_Get_information_id>
if ( !information )
ffc0d000: 7c 7d 1b 79 mr. r29,r3
ffc0d004: 41 82 00 e8 beq- ffc0d0ec <_Objects_Get_name_as_string+0x130>
return NULL;
the_object = _Objects_Get( information, tmpId, &location );
ffc0d008: 7f 84 e3 78 mr r4,r28
ffc0d00c: 38 a1 00 08 addi r5,r1,8
ffc0d010: 48 00 01 25 bl ffc0d134 <_Objects_Get>
switch ( location ) {
ffc0d014: 80 01 00 08 lwz r0,8(r1)
ffc0d018: 2f 80 00 00 cmpwi cr7,r0,0
ffc0d01c: 40 9e 00 d0 bne- cr7,ffc0d0ec <_Objects_Get_name_as_string+0x130>
return NULL;
case OBJECTS_LOCAL:
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
ffc0d020: 88 1d 00 38 lbz r0,56(r29)
ffc0d024: 2f 80 00 00 cmpwi cr7,r0,0
ffc0d028: 40 9e 00 ec bne- cr7,ffc0d114 <_Objects_Get_name_as_string+0x158>
s = the_object->name.name_p;
} else
#endif
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
ffc0d02c: 81 23 00 0c lwz r9,12(r3)
lname[ 0 ] = (u32_name >> 24) & 0xff;
lname[ 1 ] = (u32_name >> 16) & 0xff;
lname[ 2 ] = (u32_name >> 8) & 0xff;
lname[ 3 ] = (u32_name >> 0) & 0xff;
lname[ 4 ] = '\0';
ffc0d030: 98 01 00 10 stb r0,16(r1)
#endif
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
lname[ 0 ] = (u32_name >> 24) & 0xff;
lname[ 1 ] = (u32_name >> 16) & 0xff;
ffc0d034: 55 2b 84 3e rlwinm r11,r9,16,16,31
lname[ 2 ] = (u32_name >> 8) & 0xff;
ffc0d038: 55 20 c2 3e rlwinm r0,r9,24,8,31
#endif
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
lname[ 0 ] = (u32_name >> 24) & 0xff;
lname[ 1 ] = (u32_name >> 16) & 0xff;
ffc0d03c: 99 61 00 0d stb r11,13(r1)
} else
#endif
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
lname[ 0 ] = (u32_name >> 24) & 0xff;
ffc0d040: 55 2a 46 3e rlwinm r10,r9,8,24,31
lname[ 1 ] = (u32_name >> 16) & 0xff;
lname[ 2 ] = (u32_name >> 8) & 0xff;
ffc0d044: 98 01 00 0e stb r0,14(r1)
lname[ 3 ] = (u32_name >> 0) & 0xff;
ffc0d048: 99 21 00 0f stb r9,15(r1)
} else
#endif
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
lname[ 0 ] = (u32_name >> 24) & 0xff;
ffc0d04c: 99 41 00 0c stb r10,12(r1)
lname[ 1 ] = (u32_name >> 16) & 0xff;
lname[ 2 ] = (u32_name >> 8) & 0xff;
lname[ 3 ] = (u32_name >> 0) & 0xff;
lname[ 4 ] = '\0';
s = lname;
ffc0d050: 39 41 00 0c addi r10,r1,12
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
ffc0d054: 34 1e ff ff addic. r0,r30,-1
ffc0d058: 7f e9 fb 78 mr r9,r31
ffc0d05c: 7c 09 03 a6 mtctr r0
ffc0d060: 41 82 00 4c beq- ffc0d0ac <_Objects_Get_name_as_string+0xf0><== NEVER TAKEN
ffc0d064: 88 0a 00 00 lbz r0,0(r10)
ffc0d068: 2f 80 00 00 cmpwi cr7,r0,0
ffc0d06c: 41 9e 00 40 beq- cr7,ffc0d0ac <_Objects_Get_name_as_string+0xf0>
ffc0d070: 3d 00 00 00 lis r8,0
ffc0d074: 39 08 27 ec addi r8,r8,10220
ffc0d078: 48 00 00 10 b ffc0d088 <_Objects_Get_name_as_string+0xcc>
ffc0d07c: 8c 0a 00 01 lbzu r0,1(r10)
ffc0d080: 2f 80 00 00 cmpwi cr7,r0,0
ffc0d084: 41 9e 00 28 beq- cr7,ffc0d0ac <_Objects_Get_name_as_string+0xf0>
*d = (isprint((unsigned char)*s)) ? *s : '*';
ffc0d088: 81 68 00 00 lwz r11,0(r8)
ffc0d08c: 7d 6b 02 14 add r11,r11,r0
ffc0d090: 89 6b 00 01 lbz r11,1(r11)
ffc0d094: 71 67 00 97 andi. r7,r11,151
ffc0d098: 40 82 00 08 bne- ffc0d0a0 <_Objects_Get_name_as_string+0xe4>
ffc0d09c: 38 00 00 2a li r0,42
ffc0d0a0: 98 09 00 00 stb r0,0(r9)
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
ffc0d0a4: 39 29 00 01 addi r9,r9,1
ffc0d0a8: 42 00 ff d4 bdnz+ ffc0d07c <_Objects_Get_name_as_string+0xc0>
*d = (isprint((unsigned char)*s)) ? *s : '*';
}
}
*d = '\0';
ffc0d0ac: 38 00 00 00 li r0,0
ffc0d0b0: 98 09 00 00 stb r0,0(r9)
_Thread_Enable_dispatch();
ffc0d0b4: 48 00 11 61 bl ffc0e214 <_Thread_Enable_dispatch>
return name;
}
return NULL; /* unreachable path */
}
ffc0d0b8: 80 01 00 2c lwz r0,44(r1)
ffc0d0bc: 7f e3 fb 78 mr r3,r31
ffc0d0c0: 83 81 00 18 lwz r28,24(r1)
ffc0d0c4: 7c 08 03 a6 mtlr r0
ffc0d0c8: 83 a1 00 1c lwz r29,28(r1)
ffc0d0cc: 83 c1 00 20 lwz r30,32(r1)
ffc0d0d0: 83 e1 00 24 lwz r31,36(r1)
ffc0d0d4: 38 21 00 28 addi r1,r1,40
ffc0d0d8: 4e 80 00 20 blr
return NULL;
if ( name == NULL )
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
ffc0d0dc: 3d 20 00 00 lis r9,0
ffc0d0e0: 81 29 35 b0 lwz r9,13744(r9)
ffc0d0e4: 83 89 00 08 lwz r28,8(r9)
ffc0d0e8: 4b ff ff 10 b ffc0cff8 <_Objects_Get_name_as_string+0x3c>
_Thread_Enable_dispatch();
return name;
}
return NULL; /* unreachable path */
}
ffc0d0ec: 80 01 00 2c lwz r0,44(r1)
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
/* not supported */
#endif
case OBJECTS_ERROR:
return NULL;
ffc0d0f0: 3b e0 00 00 li r31,0
_Thread_Enable_dispatch();
return name;
}
return NULL; /* unreachable path */
}
ffc0d0f4: 7f e3 fb 78 mr r3,r31
ffc0d0f8: 83 81 00 18 lwz r28,24(r1)
ffc0d0fc: 7c 08 03 a6 mtlr r0
ffc0d100: 83 a1 00 1c lwz r29,28(r1)
ffc0d104: 83 c1 00 20 lwz r30,32(r1)
ffc0d108: 83 e1 00 24 lwz r31,36(r1)
ffc0d10c: 38 21 00 28 addi r1,r1,40
ffc0d110: 4e 80 00 20 blr
case OBJECTS_LOCAL:
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
s = the_object->name.name_p;
ffc0d114: 81 43 00 0c lwz r10,12(r3)
lname[ 4 ] = '\0';
s = lname;
}
d = name;
if ( s ) {
ffc0d118: 7f e9 fb 78 mr r9,r31
ffc0d11c: 2f 8a 00 00 cmpwi cr7,r10,0
ffc0d120: 40 9e ff 34 bne+ cr7,ffc0d054 <_Objects_Get_name_as_string+0x98>
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
*d = (isprint((unsigned char)*s)) ? *s : '*';
}
}
*d = '\0';
ffc0d124: 38 00 00 00 li r0,0
ffc0d128: 98 09 00 00 stb r0,0(r9)
_Thread_Enable_dispatch();
ffc0d12c: 48 00 10 e9 bl ffc0e214 <_Thread_Enable_dispatch>
ffc0d130: 4b ff ff 88 b ffc0d0b8 <_Objects_Get_name_as_string+0xfc>
ffc0af48 <_Objects_Get_next>:
Objects_Information *information,
Objects_Id id,
Objects_Locations *location_p,
Objects_Id *next_id_p
)
{
ffc0af48: 94 21 ff e8 stwu r1,-24(r1)
ffc0af4c: 7c 08 02 a6 mflr r0
ffc0af50: 93 c1 00 10 stw r30,16(r1)
Objects_Control *object;
Objects_Id next_id;
if ( !information )
ffc0af54: 7c 7e 1b 79 mr. r30,r3
return NULL;
ffc0af58: 38 60 00 00 li r3,0
Objects_Information *information,
Objects_Id id,
Objects_Locations *location_p,
Objects_Id *next_id_p
)
{
ffc0af5c: 93 81 00 08 stw r28,8(r1)
ffc0af60: 7c dc 33 78 mr r28,r6
ffc0af64: 93 e1 00 14 stw r31,20(r1)
ffc0af68: 7c bf 2b 78 mr r31,r5
ffc0af6c: 90 01 00 1c stw r0,28(r1)
ffc0af70: 93 a1 00 0c stw r29,12(r1)
Objects_Control *object;
Objects_Id next_id;
if ( !information )
ffc0af74: 41 82 00 58 beq- ffc0afcc <_Objects_Get_next+0x84>
return NULL;
if ( !location_p )
ffc0af78: 2f 85 00 00 cmpwi cr7,r5,0
ffc0af7c: 41 9e 00 50 beq- cr7,ffc0afcc <_Objects_Get_next+0x84>
return NULL;
if ( !next_id_p )
ffc0af80: 2f 86 00 00 cmpwi cr7,r6,0
ffc0af84: 41 9e 00 48 beq- cr7,ffc0afcc <_Objects_Get_next+0x84>
return NULL;
if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)
ffc0af88: 54 80 04 3e clrlwi r0,r4,16
ffc0af8c: 2f 80 00 00 cmpwi cr7,r0,0
next_id = information->minimum_id;
else
next_id = id;
ffc0af90: 7c 9d 23 78 mr r29,r4
return NULL;
if ( !next_id_p )
return NULL;
if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)
ffc0af94: 41 9e 00 58 beq- cr7,ffc0afec <_Objects_Get_next+0xa4>
else
next_id = id;
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
ffc0af98: a1 3e 00 10 lhz r9,16(r30)
ffc0af9c: 57 a0 04 3e clrlwi r0,r29,16
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
ffc0afa0: 7f a4 eb 78 mr r4,r29
else
next_id = id;
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
ffc0afa4: 7f 89 00 40 cmplw cr7,r9,r0
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
ffc0afa8: 7f c3 f3 78 mr r3,r30
ffc0afac: 7f e5 fb 78 mr r5,r31
next_id++;
ffc0afb0: 3b bd 00 01 addi r29,r29,1
else
next_id = id;
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
ffc0afb4: 41 9c 00 5c blt- cr7,ffc0b010 <_Objects_Get_next+0xc8>
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
ffc0afb8: 48 00 00 8d bl ffc0b044 <_Objects_Get>
next_id++;
} while (*location_p != OBJECTS_LOCAL);
ffc0afbc: 80 1f 00 00 lwz r0,0(r31)
ffc0afc0: 2f 80 00 00 cmpwi cr7,r0,0
ffc0afc4: 40 9e ff d4 bne+ cr7,ffc0af98 <_Objects_Get_next+0x50>
*next_id_p = next_id;
ffc0afc8: 93 bc 00 00 stw r29,0(r28)
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
return 0;
}
ffc0afcc: 80 01 00 1c lwz r0,28(r1)
ffc0afd0: 83 81 00 08 lwz r28,8(r1)
ffc0afd4: 7c 08 03 a6 mtlr r0
ffc0afd8: 83 a1 00 0c lwz r29,12(r1)
ffc0afdc: 83 c1 00 10 lwz r30,16(r1)
ffc0afe0: 83 e1 00 14 lwz r31,20(r1)
ffc0afe4: 38 21 00 18 addi r1,r1,24
ffc0afe8: 4e 80 00 20 blr
if ( !next_id_p )
return NULL;
if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)
next_id = information->minimum_id;
ffc0afec: 83 be 00 08 lwz r29,8(r30)
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
ffc0aff0: 7f c3 f3 78 mr r3,r30
else
next_id = id;
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
ffc0aff4: a1 3e 00 10 lhz r9,16(r30)
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
ffc0aff8: 7f e5 fb 78 mr r5,r31
else
next_id = id;
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
ffc0affc: 57 a0 04 3e clrlwi r0,r29,16
ffc0b000: 7f 89 00 40 cmplw cr7,r9,r0
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
ffc0b004: 7f a4 eb 78 mr r4,r29
next_id++;
ffc0b008: 3b bd 00 01 addi r29,r29,1
else
next_id = id;
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
ffc0b00c: 40 9c ff ac bge+ cr7,ffc0afb8 <_Objects_Get_next+0x70> <== ALWAYS TAKEN
{
*location_p = OBJECTS_ERROR;
ffc0b010: 38 00 00 01 li r0,1
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
return 0;
}
ffc0b014: 83 a1 00 0c lwz r29,12(r1)
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
{
*location_p = OBJECTS_ERROR;
ffc0b018: 90 1f 00 00 stw r0,0(r31)
*next_id_p = next_id;
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
ffc0b01c: 38 00 ff ff li r0,-1
return 0;
ffc0b020: 38 60 00 00 li r3,0
*next_id_p = next_id;
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
ffc0b024: 90 1c 00 00 stw r0,0(r28)
return 0;
}
ffc0b028: 80 01 00 1c lwz r0,28(r1)
ffc0b02c: 83 81 00 08 lwz r28,8(r1)
ffc0b030: 7c 08 03 a6 mtlr r0
ffc0b034: 83 c1 00 10 lwz r30,16(r1)
ffc0b038: 83 e1 00 14 lwz r31,20(r1)
ffc0b03c: 38 21 00 18 addi r1,r1,24
ffc0b040: 4e 80 00 20 blr
ffc0bf2c <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
ffc0bf2c: 94 21 ff e0 stwu r1,-32(r1)
ffc0bf30: 7c 08 02 a6 mflr r0
ffc0bf34: 90 01 00 24 stw r0,36(r1)
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
ffc0bf38: 7c 60 1b 79 mr. r0,r3
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
ffc0bf3c: 93 c1 00 18 stw r30,24(r1)
ffc0bf40: 7c 9e 23 78 mr r30,r4
ffc0bf44: 93 e1 00 1c stw r31,28(r1)
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
ffc0bf48: 40 82 00 10 bne- ffc0bf58 <_Objects_Id_to_name+0x2c>
ffc0bf4c: 3d 20 00 00 lis r9,0
ffc0bf50: 81 29 31 b0 lwz r9,12720(r9)
ffc0bf54: 80 09 00 08 lwz r0,8(r9)
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
ffc0bf58: 54 09 47 7e rlwinm r9,r0,8,29,31
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
ffc0bf5c: 39 69 ff ff addi r11,r9,-1
ffc0bf60: 2b 8b 00 02 cmplwi cr7,r11,2
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
ffc0bf64: 3b e0 00 03 li r31,3
ffc0bf68: 41 9d 00 38 bgt- cr7,ffc0bfa0 <_Objects_Id_to_name+0x74>
if ( !_Objects_Information_table[ the_api ] )
ffc0bf6c: 3d 60 00 00 lis r11,0
ffc0bf70: 55 29 10 3a rlwinm r9,r9,2,0,29
ffc0bf74: 39 6b 2c c0 addi r11,r11,11456
ffc0bf78: 7d 2b 48 2e lwzx r9,r11,r9
ffc0bf7c: 2f 89 00 00 cmpwi cr7,r9,0
ffc0bf80: 41 9e 00 20 beq- cr7,ffc0bfa0 <_Objects_Id_to_name+0x74>
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
ffc0bf84: 54 0b 3e 7a rlwinm r11,r0,7,25,29
ffc0bf88: 7c 69 58 2e lwzx r3,r9,r11
if ( !information )
ffc0bf8c: 2f 83 00 00 cmpwi cr7,r3,0
ffc0bf90: 41 9e 00 10 beq- cr7,ffc0bfa0 <_Objects_Id_to_name+0x74><== NEVER TAKEN
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
ffc0bf94: 89 23 00 38 lbz r9,56(r3)
ffc0bf98: 2f 89 00 00 cmpwi cr7,r9,0
ffc0bf9c: 41 9e 00 20 beq- cr7,ffc0bfbc <_Objects_Id_to_name+0x90><== ALWAYS TAKEN
return OBJECTS_INVALID_ID;
*name = the_object->name;
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
ffc0bfa0: 80 01 00 24 lwz r0,36(r1)
ffc0bfa4: 7f e3 fb 78 mr r3,r31
ffc0bfa8: 83 c1 00 18 lwz r30,24(r1)
ffc0bfac: 7c 08 03 a6 mtlr r0
ffc0bfb0: 83 e1 00 1c lwz r31,28(r1)
ffc0bfb4: 38 21 00 20 addi r1,r1,32
ffc0bfb8: 4e 80 00 20 blr
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
ffc0bfbc: 7c 04 03 78 mr r4,r0
ffc0bfc0: 38 a1 00 08 addi r5,r1,8
ffc0bfc4: 4b ff fe c9 bl ffc0be8c <_Objects_Get>
if ( !the_object )
ffc0bfc8: 2c 03 00 00 cmpwi r3,0
ffc0bfcc: 41 a2 ff d4 beq- ffc0bfa0 <_Objects_Id_to_name+0x74>
return OBJECTS_INVALID_ID;
*name = the_object->name;
ffc0bfd0: 80 03 00 0c lwz r0,12(r3)
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
ffc0bfd4: 3b e0 00 00 li r31,0
the_object = _Objects_Get( information, tmpId, &ignored_location );
if ( !the_object )
return OBJECTS_INVALID_ID;
*name = the_object->name;
ffc0bfd8: 90 1e 00 00 stw r0,0(r30)
_Thread_Enable_dispatch();
ffc0bfdc: 48 00 10 49 bl ffc0d024 <_Thread_Enable_dispatch>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
ffc0bfe0: 4b ff ff c0 b ffc0bfa0 <_Objects_Id_to_name+0x74>
ffc0b668 <_Objects_Shrink_information>:
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
ffc0b668: 94 21 ff e8 stwu r1,-24(r1)
ffc0b66c: 7c 08 02 a6 mflr r0
ffc0b670: 90 01 00 1c stw r0,28(r1)
ffc0b674: 93 e1 00 14 stw r31,20(r1)
/*
* Search the list to find block or chunk with all objects inactive.
*/
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
ffc0b678: a1 43 00 10 lhz r10,16(r3)
/*
* Search the list to find block or chunk with all objects inactive.
*/
index_base = _Objects_Get_index( information->minimum_id );
ffc0b67c: a3 e3 00 0a lhz r31,10(r3)
block_count = (information->maximum - index_base) /
ffc0b680: a0 03 00 14 lhz r0,20(r3)
ffc0b684: 7d 5f 50 50 subf r10,r31,r10
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
ffc0b688: 93 81 00 08 stw r28,8(r1)
/*
* Search the list to find block or chunk with all objects inactive.
*/
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
ffc0b68c: 7d 4a 03 96 divwu r10,r10,r0
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
ffc0b690: 93 a1 00 0c stw r29,12(r1)
ffc0b694: 93 c1 00 10 stw r30,16(r1)
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
ffc0b698: 2f 8a 00 00 cmpwi cr7,r10,0
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
ffc0b69c: 7c 7c 1b 78 mr r28,r3
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
ffc0b6a0: 41 9e 00 3c beq- cr7,ffc0b6dc <_Objects_Shrink_information+0x74><== NEVER TAKEN
if ( information->inactive_per_block[ block ] ==
ffc0b6a4: 81 63 00 30 lwz r11,48(r3)
ffc0b6a8: 81 2b 00 00 lwz r9,0(r11)
ffc0b6ac: 7f 80 48 00 cmpw cr7,r0,r9
ffc0b6b0: 41 9e 00 4c beq- cr7,ffc0b6fc <_Objects_Shrink_information+0x94><== NEVER TAKEN
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
ffc0b6b4: 39 20 00 00 li r9,0
ffc0b6b8: 7d 49 03 a6 mtctr r10
ffc0b6bc: 48 00 00 18 b ffc0b6d4 <_Objects_Shrink_information+0x6c>
if ( information->inactive_per_block[ block ] ==
ffc0b6c0: 85 4b 00 04 lwzu r10,4(r11)
information->inactive -= information->allocation_size;
return;
}
index_base += information->allocation_size;
ffc0b6c4: 7f ff 02 14 add r31,r31,r0
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
if ( information->inactive_per_block[ block ] ==
ffc0b6c8: 55 3d 10 3a rlwinm r29,r9,2,0,29
ffc0b6cc: 7f 80 50 00 cmpw cr7,r0,r10
ffc0b6d0: 41 9e 00 30 beq- cr7,ffc0b700 <_Objects_Shrink_information+0x98>
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
ffc0b6d4: 39 29 00 01 addi r9,r9,1
ffc0b6d8: 42 00 ff e8 bdnz+ ffc0b6c0 <_Objects_Shrink_information+0x58>
return;
}
index_base += information->allocation_size;
}
}
ffc0b6dc: 80 01 00 1c lwz r0,28(r1)
ffc0b6e0: 83 81 00 08 lwz r28,8(r1)
ffc0b6e4: 7c 08 03 a6 mtlr r0
ffc0b6e8: 83 a1 00 0c lwz r29,12(r1)
ffc0b6ec: 83 c1 00 10 lwz r30,16(r1)
ffc0b6f0: 83 e1 00 14 lwz r31,20(r1)
ffc0b6f4: 38 21 00 18 addi r1,r1,24
ffc0b6f8: 4e 80 00 20 blr
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
if ( information->inactive_per_block[ block ] ==
ffc0b6fc: 3b a0 00 00 li r29,0 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc0b700: 80 7c 00 20 lwz r3,32(r28)
ffc0b704: 48 00 00 10 b ffc0b714 <_Objects_Shrink_information+0xac>
if ((index >= index_base) &&
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
}
}
while ( the_object );
ffc0b708: 2f 9e 00 00 cmpwi cr7,r30,0
index = _Objects_Get_index( the_object->id );
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
ffc0b70c: 7f c3 f3 78 mr r3,r30
if ((index >= index_base) &&
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
}
}
while ( the_object );
ffc0b710: 41 9e 00 34 beq- cr7,ffc0b744 <_Objects_Shrink_information+0xdc>
* Assume the Inactive chain is never empty at this point
*/
the_object = (Objects_Control *) _Chain_First( &information->Inactive );
do {
index = _Objects_Get_index( the_object->id );
ffc0b714: a0 03 00 0a lhz r0,10(r3)
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
ffc0b718: 83 c3 00 00 lwz r30,0(r3)
if ((index >= index_base) &&
ffc0b71c: 7f 80 f8 40 cmplw cr7,r0,r31
ffc0b720: 41 bc ff e8 blt- cr7,ffc0b708 <_Objects_Shrink_information+0xa0>
(index < (index_base + information->allocation_size))) {
ffc0b724: a1 3c 00 14 lhz r9,20(r28)
ffc0b728: 7d 3f 4a 14 add r9,r31,r9
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
if ((index >= index_base) &&
ffc0b72c: 7f 80 48 40 cmplw cr7,r0,r9
ffc0b730: 40 9c ff d8 bge+ cr7,ffc0b708 <_Objects_Shrink_information+0xa0>
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
ffc0b734: 4b ff ea e9 bl ffc0a21c <_Chain_Extract>
}
}
while ( the_object );
ffc0b738: 2f 9e 00 00 cmpwi cr7,r30,0
index = _Objects_Get_index( the_object->id );
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
ffc0b73c: 7f c3 f3 78 mr r3,r30
if ((index >= index_base) &&
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
}
}
while ( the_object );
ffc0b740: 40 9e ff d4 bne+ cr7,ffc0b714 <_Objects_Shrink_information+0xac><== ALWAYS TAKEN
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
ffc0b744: 81 3c 00 34 lwz r9,52(r28)
ffc0b748: 7c 69 e8 2e lwzx r3,r9,r29
ffc0b74c: 48 00 24 d9 bl ffc0dc24 <_Workspace_Free>
information->object_blocks[ block ] = NULL;
ffc0b750: 81 3c 00 34 lwz r9,52(r28)
information->inactive_per_block[ block ] = 0;
information->inactive -= information->allocation_size;
ffc0b754: a1 7c 00 2c lhz r11,44(r28)
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
information->object_blocks[ block ] = NULL;
ffc0b758: 7f c9 e9 2e stwx r30,r9,r29
information->inactive_per_block[ block ] = 0;
information->inactive -= information->allocation_size;
ffc0b75c: a0 1c 00 14 lhz r0,20(r28)
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
information->object_blocks[ block ] = NULL;
information->inactive_per_block[ block ] = 0;
ffc0b760: 81 3c 00 30 lwz r9,48(r28)
information->inactive -= information->allocation_size;
ffc0b764: 7c 00 58 50 subf r0,r0,r11
return;
}
index_base += information->allocation_size;
}
}
ffc0b768: 83 e1 00 14 lwz r31,20(r1)
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
information->object_blocks[ block ] = NULL;
information->inactive_per_block[ block ] = 0;
ffc0b76c: 7f c9 e9 2e stwx r30,r9,r29
information->inactive -= information->allocation_size;
ffc0b770: b0 1c 00 2c sth r0,44(r28)
return;
}
index_base += information->allocation_size;
}
}
ffc0b774: 80 01 00 1c lwz r0,28(r1)
ffc0b778: 83 81 00 08 lwz r28,8(r1)
ffc0b77c: 7c 08 03 a6 mtlr r0
ffc0b780: 83 a1 00 0c lwz r29,12(r1)
ffc0b784: 83 c1 00 10 lwz r30,16(r1)
ffc0b788: 38 21 00 18 addi r1,r1,24
ffc0b78c: 4e 80 00 20 blr
ffc0b4e0 <_POSIX_Absolute_timeout_to_ticks>:
*/
POSIX_Absolute_timeout_conversion_results_t _POSIX_Absolute_timeout_to_ticks(
const struct timespec *abstime,
Watchdog_Interval *ticks_out
)
{
ffc0b4e0: 94 21 ff e0 stwu r1,-32(r1)
ffc0b4e4: 7c 08 02 a6 mflr r0
ffc0b4e8: 90 01 00 24 stw r0,36(r1)
/*
* Make sure there is always a value returned.
*/
*ticks_out = 0;
ffc0b4ec: 38 00 00 00 li r0,0
*/
POSIX_Absolute_timeout_conversion_results_t _POSIX_Absolute_timeout_to_ticks(
const struct timespec *abstime,
Watchdog_Interval *ticks_out
)
{
ffc0b4f0: 93 c1 00 18 stw r30,24(r1)
ffc0b4f4: 7c 7e 1b 78 mr r30,r3
ffc0b4f8: 93 e1 00 1c stw r31,28(r1)
ffc0b4fc: 7c 9f 23 78 mr r31,r4
/*
* Make sure there is always a value returned.
*/
*ticks_out = 0;
ffc0b500: 90 04 00 00 stw r0,0(r4)
/*
* Is the absolute time even valid?
*/
if ( !_Timespec_Is_valid(abstime) )
ffc0b504: 48 00 53 99 bl ffc1089c <_Timespec_Is_valid>
ffc0b508: 2f 83 00 00 cmpwi cr7,r3,0
return POSIX_ABSOLUTE_TIMEOUT_INVALID;
ffc0b50c: 38 60 00 00 li r3,0
*ticks_out = 0;
/*
* Is the absolute time even valid?
*/
if ( !_Timespec_Is_valid(abstime) )
ffc0b510: 40 9e 00 1c bne- cr7,ffc0b52c <_POSIX_Absolute_timeout_to_ticks+0x4c>
/*
* This is the case we were expecting and it took this long to
* get here.
*/
return POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE;
}
ffc0b514: 80 01 00 24 lwz r0,36(r1)
ffc0b518: 83 c1 00 18 lwz r30,24(r1)
ffc0b51c: 7c 08 03 a6 mtlr r0
ffc0b520: 83 e1 00 1c lwz r31,28(r1)
ffc0b524: 38 21 00 20 addi r1,r1,32
ffc0b528: 4e 80 00 20 blr
return POSIX_ABSOLUTE_TIMEOUT_INVALID;
/*
* Is the absolute time in the past?
*/
_TOD_Get( ¤t_time );
ffc0b52c: 38 61 00 10 addi r3,r1,16
ffc0b530: 48 00 27 69 bl ffc0dc98 <_TOD_Get>
if ( _Timespec_Less_than( abstime, ¤t_time ) )
ffc0b534: 7f c3 f3 78 mr r3,r30
ffc0b538: 38 81 00 10 addi r4,r1,16
ffc0b53c: 48 00 53 9d bl ffc108d8 <_Timespec_Less_than>
ffc0b540: 2f 83 00 00 cmpwi cr7,r3,0
return POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST;
ffc0b544: 38 60 00 01 li r3,1
/*
* Is the absolute time in the past?
*/
_TOD_Get( ¤t_time );
if ( _Timespec_Less_than( abstime, ¤t_time ) )
ffc0b548: 40 9e ff cc bne+ cr7,ffc0b514 <_POSIX_Absolute_timeout_to_ticks+0x34>
return POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST;
/*
* How long until the requested absolute time?
*/
_Timespec_Subtract( ¤t_time, abstime, &difference );
ffc0b54c: 7f c4 f3 78 mr r4,r30
ffc0b550: 38 a1 00 08 addi r5,r1,8
ffc0b554: 38 61 00 10 addi r3,r1,16
ffc0b558: 48 00 53 bd bl ffc10914 <_Timespec_Subtract>
/*
* Internally the SuperCore uses ticks, so convert to them.
*/
*ticks_out = _Timespec_To_ticks( &difference );
ffc0b55c: 38 61 00 08 addi r3,r1,8
ffc0b560: 48 00 54 01 bl ffc10960 <_Timespec_To_ticks>
/*
* If the difference was 0, then the future is now. It is so bright
* we better wear shades.
*/
if ( !*ticks_out )
ffc0b564: 2f 83 00 00 cmpwi cr7,r3,0
_Timespec_Subtract( ¤t_time, abstime, &difference );
/*
* Internally the SuperCore uses ticks, so convert to them.
*/
*ticks_out = _Timespec_To_ticks( &difference );
ffc0b568: 90 7f 00 00 stw r3,0(r31)
/*
* This is the case we were expecting and it took this long to
* get here.
*/
return POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE;
ffc0b56c: 38 60 00 03 li r3,3
/*
* If the difference was 0, then the future is now. It is so bright
* we better wear shades.
*/
if ( !*ticks_out )
ffc0b570: 40 be ff a4 bne- cr7,ffc0b514 <_POSIX_Absolute_timeout_to_ticks+0x34><== ALWAYS TAKEN
return POSIX_ABSOLUTE_TIMEOUT_IS_NOW;
ffc0b574: 38 60 00 02 li r3,2 <== NOT EXECUTED
ffc0b578: 4b ff ff 9c b ffc0b514 <_POSIX_Absolute_timeout_to_ticks+0x34><== NOT EXECUTED
ffc13228 <_POSIX_Keys_Run_destructors>:
*/
void _POSIX_Keys_Run_destructors(
Thread_Control *thread
)
{
ffc13228: 94 21 ff e0 stwu r1,-32(r1)
ffc1322c: 7c 08 02 a6 mflr r0
ffc13230: 90 01 00 24 stw r0,36(r1)
ffc13234: 93 81 00 10 stw r28,16(r1)
Objects_Maximum thread_index = _Objects_Get_index( thread->Object.id );
ffc13238: 83 83 00 08 lwz r28,8(r3)
*/
void _POSIX_Keys_Run_destructors(
Thread_Control *thread
)
{
ffc1323c: 93 61 00 0c stw r27,12(r1)
for ( index = 1 ; index <= max ; ++index ) {
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
void *value = key->Values [ thread_api ][ thread_index ];
ffc13240: 57 9b 56 fa rlwinm r27,r28,10,27,29
*/
void _POSIX_Keys_Run_destructors(
Thread_Control *thread
)
{
ffc13244: 93 c1 00 18 stw r30,24(r1)
ffc13248: 3f c0 00 00 lis r30,0
for ( index = 1 ; index <= max ; ++index ) {
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
void *value = key->Values [ thread_api ][ thread_index ];
ffc1324c: 57 9c 13 ba rlwinm r28,r28,2,14,29
*/
void _POSIX_Keys_Run_destructors(
Thread_Control *thread
)
{
ffc13250: 93 a1 00 14 stw r29,20(r1)
ffc13254: 3b de 30 24 addi r30,r30,12324
for ( index = 1 ; index <= max ; ++index ) {
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
void *value = key->Values [ thread_api ][ thread_index ];
ffc13258: 3b 7b 00 10 addi r27,r27,16
*/
void _POSIX_Keys_Run_destructors(
Thread_Control *thread
)
{
ffc1325c: 93 e1 00 1c stw r31,28(r1)
ffc13260: 93 41 00 08 stw r26,8(r1)
if ( key != NULL && key->destructor != NULL ) {
void *value = key->Values [ thread_api ][ thread_index ];
if ( value != NULL ) {
key->Values [ thread_api ][ thread_index ] = NULL;
ffc13264: 3b 40 00 00 li r26,0
*
* Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99.
*/
while ( !done ) {
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
ffc13268: a3 fe 00 10 lhz r31,16(r30)
done = true;
for ( index = 1 ; index <= max ; ++index ) {
ffc1326c: 2f 9f 00 00 cmpwi cr7,r31,0
ffc13270: 40 9e 00 2c bne- cr7,ffc1329c <_POSIX_Keys_Run_destructors+0x74>
done = false;
}
}
}
}
}
ffc13274: 80 01 00 24 lwz r0,36(r1)
ffc13278: 83 41 00 08 lwz r26,8(r1)
ffc1327c: 7c 08 03 a6 mtlr r0
ffc13280: 83 61 00 0c lwz r27,12(r1)
ffc13284: 83 81 00 10 lwz r28,16(r1)
ffc13288: 83 a1 00 14 lwz r29,20(r1)
ffc1328c: 83 c1 00 18 lwz r30,24(r1)
ffc13290: 83 e1 00 1c lwz r31,28(r1)
ffc13294: 38 21 00 20 addi r1,r1,32
ffc13298: 4e 80 00 20 blr
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
ffc1329c: 3b a0 00 01 li r29,1
ffc132a0: 38 00 00 01 li r0,1
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
ffc132a4: 81 7e 00 1c lwz r11,28(r30)
ffc132a8: 57 a9 10 3a rlwinm r9,r29,2,0,29
ffc132ac: 7d 2b 48 2e lwzx r9,r11,r9
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
ffc132b0: 2f 89 00 00 cmpwi cr7,r9,0
void *value = key->Values [ thread_api ][ thread_index ];
ffc132b4: 7d 69 da 14 add r11,r9,r27
for ( index = 1 ; index <= max ; ++index ) {
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
ffc132b8: 41 9e 00 34 beq- cr7,ffc132ec <_POSIX_Keys_Run_destructors+0xc4>
ffc132bc: 81 49 00 10 lwz r10,16(r9)
ffc132c0: 2f 8a 00 00 cmpwi cr7,r10,0
ffc132c4: 41 9e 00 28 beq- cr7,ffc132ec <_POSIX_Keys_Run_destructors+0xc4>
void *value = key->Values [ thread_api ][ thread_index ];
ffc132c8: 81 6b 00 04 lwz r11,4(r11)
ffc132cc: 7c 6b e0 2e lwzx r3,r11,r28
if ( value != NULL ) {
ffc132d0: 2f 83 00 00 cmpwi cr7,r3,0
ffc132d4: 41 9e 00 18 beq- cr7,ffc132ec <_POSIX_Keys_Run_destructors+0xc4><== ALWAYS TAKEN
key->Values [ thread_api ][ thread_index ] = NULL;
ffc132d8: 7f 4b e1 2e stwx r26,r11,r28 <== NOT EXECUTED
(*key->destructor)( value );
ffc132dc: 80 09 00 10 lwz r0,16(r9) <== NOT EXECUTED
ffc132e0: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc132e4: 4e 80 04 21 bctrl <== NOT EXECUTED
done = false;
ffc132e8: 38 00 00 00 li r0,0 <== NOT EXECUTED
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
ffc132ec: 3b bd 00 01 addi r29,r29,1
ffc132f0: 57 bd 04 3e clrlwi r29,r29,16
ffc132f4: 7f 9f e8 40 cmplw cr7,r31,r29
ffc132f8: 40 bc ff ac bge- cr7,ffc132a4 <_POSIX_Keys_Run_destructors+0x7c>
* number of iterations. An infinite loop may happen if destructors set
* thread specific data. This can be considered dubious.
*
* Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99.
*/
while ( !done ) {
ffc132fc: 2f 80 00 00 cmpwi cr7,r0,0
ffc13300: 41 9e ff 68 beq+ cr7,ffc13268 <_POSIX_Keys_Run_destructors+0x40><== NEVER TAKEN
ffc13304: 4b ff ff 70 b ffc13274 <_POSIX_Keys_Run_destructors+0x4c>
ffc0ef8c <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
ffc0ef8c: 94 21 ff d0 stwu r1,-48(r1)
ffc0ef90: 7c 08 02 a6 mflr r0
ffc0ef94: 93 e1 00 2c stw r31,44(r1)
ffc0ef98: 7c 7f 1b 78 mr r31,r3
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(
ffc0ef9c: 3c 60 00 00 lis r3,0
ffc0efa0: 93 81 00 20 stw r28,32(r1)
ffc0efa4: 38 63 36 18 addi r3,r3,13848
ffc0efa8: 7c 9c 23 78 mr r28,r4
ffc0efac: 93 a1 00 24 stw r29,36(r1)
ffc0efb0: 7f e4 fb 78 mr r4,r31
ffc0efb4: 7c bd 2b 78 mr r29,r5
ffc0efb8: 38 a1 00 0c addi r5,r1,12
ffc0efbc: 90 01 00 34 stw r0,52(r1)
ffc0efc0: 93 41 00 18 stw r26,24(r1)
ffc0efc4: 7c fa 3b 78 mr r26,r7
ffc0efc8: 93 61 00 1c stw r27,28(r1)
ffc0efcc: 7d 1b 43 78 mr r27,r8
ffc0efd0: 93 c1 00 28 stw r30,40(r1)
ffc0efd4: 7c de 33 78 mr r30,r6
ffc0efd8: 48 00 41 7d bl ffc13154 <_Objects_Get>
Objects_Locations location;
size_t length_out;
bool do_wait;
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
ffc0efdc: 80 01 00 0c lwz r0,12(r1)
ffc0efe0: 2f 80 00 00 cmpwi cr7,r0,0
ffc0efe4: 41 9e 00 3c beq- cr7,ffc0f020 <_POSIX_Message_queue_Receive_support+0x94>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
ffc0efe8: 48 00 d4 45 bl ffc1c42c <__errno>
ffc0efec: 38 00 00 09 li r0,9
ffc0eff0: 90 03 00 00 stw r0,0(r3)
ffc0eff4: 38 60 ff ff li r3,-1
}
ffc0eff8: 80 01 00 34 lwz r0,52(r1)
ffc0effc: 83 41 00 18 lwz r26,24(r1)
ffc0f000: 7c 08 03 a6 mtlr r0
ffc0f004: 83 61 00 1c lwz r27,28(r1)
ffc0f008: 83 81 00 20 lwz r28,32(r1)
ffc0f00c: 83 a1 00 24 lwz r29,36(r1)
ffc0f010: 83 c1 00 28 lwz r30,40(r1)
ffc0f014: 83 e1 00 2c lwz r31,44(r1)
ffc0f018: 38 21 00 30 addi r1,r1,48
ffc0f01c: 4e 80 00 20 blr
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
ffc0f020: 80 03 00 14 lwz r0,20(r3)
ffc0f024: 54 09 07 be clrlwi r9,r0,30
ffc0f028: 2f 89 00 01 cmpwi cr7,r9,1
ffc0f02c: 41 9e 00 c4 beq- cr7,ffc0f0f0 <_POSIX_Message_queue_Receive_support+0x164>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
ffc0f030: 80 63 00 10 lwz r3,16(r3)
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
ffc0f034: 81 23 00 68 lwz r9,104(r3)
ffc0f038: 7f 89 e8 40 cmplw cr7,r9,r29
ffc0f03c: 41 9d 00 9c bgt- cr7,ffc0f0d8 <_POSIX_Message_queue_Receive_support+0x14c>
length_out = -1;
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
ffc0f040: 2f 9a 00 00 cmpwi cr7,r26,0
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
ffc0f044: 39 20 ff ff li r9,-1
ffc0f048: 91 21 00 08 stw r9,8(r1)
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
ffc0f04c: 38 e0 00 00 li r7,0
ffc0f050: 40 9e 00 78 bne- cr7,ffc0f0c8 <_POSIX_Message_queue_Receive_support+0x13c>
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
ffc0f054: 7f e4 fb 78 mr r4,r31
ffc0f058: 38 63 00 1c addi r3,r3,28
ffc0f05c: 7f 85 e3 78 mr r5,r28
ffc0f060: 38 c1 00 08 addi r6,r1,8
ffc0f064: 7f 68 db 78 mr r8,r27
ffc0f068: 48 00 2b d5 bl ffc11c3c <_CORE_message_queue_Seize>
);
_Thread_Enable_dispatch();
if (msg_prio) {
*msg_prio = _POSIX_Message_queue_Priority_from_core(
_Thread_Executing->Wait.count
ffc0f06c: 3f e0 00 00 lis r31,0
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
ffc0f070: 48 00 52 85 bl ffc142f4 <_Thread_Enable_dispatch>
if (msg_prio) {
ffc0f074: 2f 9e 00 00 cmpwi cr7,r30,0
*msg_prio = _POSIX_Message_queue_Priority_from_core(
_Thread_Executing->Wait.count
ffc0f078: 3b ff 36 84 addi r31,r31,13956
ffc0f07c: 81 3f 00 0c lwz r9,12(r31)
do_wait,
timeout
);
_Thread_Enable_dispatch();
if (msg_prio) {
ffc0f080: 41 9e 00 18 beq- cr7,ffc0f098 <_POSIX_Message_queue_Receive_support+0x10c><== NEVER TAKEN
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);
ffc0f084: 80 09 00 24 lwz r0,36(r9)
ffc0f088: 7c 0b fe 70 srawi r11,r0,31
ffc0f08c: 7d 60 02 78 xor r0,r11,r0
ffc0f090: 7c 0b 00 50 subf r0,r11,r0
*msg_prio = _POSIX_Message_queue_Priority_from_core(
ffc0f094: 90 1e 00 00 stw r0,0(r30)
_Thread_Executing->Wait.count
);
}
if ( !_Thread_Executing->Wait.return_code )
ffc0f098: 80 09 00 34 lwz r0,52(r9)
return length_out;
ffc0f09c: 80 61 00 08 lwz r3,8(r1)
*msg_prio = _POSIX_Message_queue_Priority_from_core(
_Thread_Executing->Wait.count
);
}
if ( !_Thread_Executing->Wait.return_code )
ffc0f0a0: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f0a4: 41 9e ff 54 beq+ cr7,ffc0eff8 <_POSIX_Message_queue_Receive_support+0x6c>
return length_out;
rtems_set_errno_and_return_minus_one(
ffc0f0a8: 48 00 d3 85 bl ffc1c42c <__errno>
ffc0f0ac: 81 3f 00 0c lwz r9,12(r31)
ffc0f0b0: 7c 7e 1b 78 mr r30,r3
ffc0f0b4: 80 69 00 34 lwz r3,52(r9)
ffc0f0b8: 48 00 03 99 bl ffc0f450 <_POSIX_Message_queue_Translate_core_message_queue_return_code>
ffc0f0bc: 90 7e 00 00 stw r3,0(r30)
ffc0f0c0: 38 60 ff ff li r3,-1
ffc0f0c4: 4b ff ff 34 b ffc0eff8 <_POSIX_Message_queue_Receive_support+0x6c>
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
ffc0f0c8: 70 09 40 00 andi. r9,r0,16384
ffc0f0cc: 7c e0 00 26 mfcr r7
ffc0f0d0: 54 e7 1f fe rlwinm r7,r7,3,31,31
ffc0f0d4: 4b ff ff 80 b ffc0f054 <_POSIX_Message_queue_Receive_support+0xc8>
}
the_mq = the_mq_fd->Queue;
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
_Thread_Enable_dispatch();
ffc0f0d8: 48 00 52 1d bl ffc142f4 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EMSGSIZE );
ffc0f0dc: 48 00 d3 51 bl ffc1c42c <__errno>
ffc0f0e0: 38 00 00 7a li r0,122
ffc0f0e4: 90 03 00 00 stw r0,0(r3)
ffc0f0e8: 38 60 ff ff li r3,-1
ffc0f0ec: 4b ff ff 0c b ffc0eff8 <_POSIX_Message_queue_Receive_support+0x6c>
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
_Thread_Enable_dispatch();
ffc0f0f0: 48 00 52 05 bl ffc142f4 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EBADF );
ffc0f0f4: 48 00 d3 39 bl ffc1c42c <__errno>
ffc0f0f8: 38 00 00 09 li r0,9
ffc0f0fc: 90 03 00 00 stw r0,0(r3)
ffc0f100: 38 60 ff ff li r3,-1
ffc0f104: 4b ff fe f4 b ffc0eff8 <_POSIX_Message_queue_Receive_support+0x6c>
ffc0f130 <_POSIX_Message_queue_Send_support>:
/*
* Validate the priority.
* XXX - Do not validate msg_prio is not less than 0.
*/
if ( msg_prio > MQ_PRIO_MAX )
ffc0f130: 2b 86 00 20 cmplwi cr7,r6,32
size_t msg_len,
uint32_t msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
ffc0f134: 94 21 ff d0 stwu r1,-48(r1)
ffc0f138: 7c 08 02 a6 mflr r0
ffc0f13c: 93 41 00 18 stw r26,24(r1)
ffc0f140: 7c fa 3b 78 mr r26,r7
ffc0f144: 93 61 00 1c stw r27,28(r1)
ffc0f148: 7c 9b 23 78 mr r27,r4
ffc0f14c: 93 81 00 20 stw r28,32(r1)
ffc0f150: 7c bc 2b 78 mr r28,r5
ffc0f154: 93 a1 00 24 stw r29,36(r1)
ffc0f158: 7c 7d 1b 78 mr r29,r3
ffc0f15c: 93 c1 00 28 stw r30,40(r1)
ffc0f160: 7c de 33 78 mr r30,r6
ffc0f164: 93 e1 00 2c stw r31,44(r1)
ffc0f168: 7d 1f 43 78 mr r31,r8
ffc0f16c: 90 01 00 34 stw r0,52(r1)
/*
* Validate the priority.
* XXX - Do not validate msg_prio is not less than 0.
*/
if ( msg_prio > MQ_PRIO_MAX )
ffc0f170: 41 9d 01 04 bgt- cr7,ffc0f274 <_POSIX_Message_queue_Send_support+0x144>
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(
ffc0f174: 3c 60 00 00 lis r3,0
ffc0f178: 38 63 36 18 addi r3,r3,13848
ffc0f17c: 7f a4 eb 78 mr r4,r29
ffc0f180: 38 a1 00 08 addi r5,r1,8
ffc0f184: 48 00 3f d1 bl ffc13154 <_Objects_Get>
rtems_set_errno_and_return_minus_one( EINVAL );
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
ffc0f188: 80 01 00 08 lwz r0,8(r1)
ffc0f18c: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f190: 40 9e 00 d0 bne- cr7,ffc0f260 <_POSIX_Message_queue_Send_support+0x130>
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) {
ffc0f194: 80 03 00 14 lwz r0,20(r3)
ffc0f198: 70 09 00 03 andi. r9,r0,3
ffc0f19c: 41 82 00 ec beq- ffc0f288 <_POSIX_Message_queue_Send_support+0x158>
the_mq = the_mq_fd->Queue;
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
ffc0f1a0: 2f 9a 00 00 cmpwi cr7,r26,0
if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
ffc0f1a4: 81 63 00 10 lwz r11,16(r3)
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
ffc0f1a8: 39 20 00 00 li r9,0
ffc0f1ac: 40 9e 00 68 bne- cr7,ffc0f214 <_POSIX_Message_queue_Send_support+0xe4>
do_wait = wait;
/*
* Now perform the actual message receive
*/
msg_status = _CORE_message_queue_Submit(
ffc0f1b0: 7f ea fb 78 mr r10,r31
ffc0f1b4: 7f 64 db 78 mr r4,r27
ffc0f1b8: 7f 85 e3 78 mr r5,r28
ffc0f1bc: 7f a6 eb 78 mr r6,r29
ffc0f1c0: 38 e0 00 00 li r7,0
ffc0f1c4: 7d 1e 00 d0 neg r8,r30
ffc0f1c8: 38 6b 00 1c addi r3,r11,28
ffc0f1cc: 48 00 2c 05 bl ffc11dd0 <_CORE_message_queue_Submit>
ffc0f1d0: 7c 7f 1b 78 mr r31,r3
_POSIX_Message_queue_Priority_to_core( msg_prio ),
do_wait,
timeout /* no timeout */
);
_Thread_Enable_dispatch();
ffc0f1d4: 48 00 51 21 bl ffc142f4 <_Thread_Enable_dispatch>
* after it wakes up. The returned status is correct for
* non-blocking operations but if we blocked, then we need
* to look at the status in our TCB.
*/
if ( msg_status == CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT )
ffc0f1d8: 2f 9f 00 07 cmpwi cr7,r31,7
ffc0f1dc: 41 9e 00 74 beq- cr7,ffc0f250 <_POSIX_Message_queue_Send_support+0x120><== NEVER TAKEN
msg_status = _Thread_Executing->Wait.return_code;
if ( !msg_status )
ffc0f1e0: 2f 9f 00 00 cmpwi cr7,r31,0
return msg_status;
ffc0f1e4: 38 60 00 00 li r3,0
*/
if ( msg_status == CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT )
msg_status = _Thread_Executing->Wait.return_code;
if ( !msg_status )
ffc0f1e8: 40 9e 00 b8 bne- cr7,ffc0f2a0 <_POSIX_Message_queue_Send_support+0x170>
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
}
ffc0f1ec: 80 01 00 34 lwz r0,52(r1)
ffc0f1f0: 83 41 00 18 lwz r26,24(r1)
ffc0f1f4: 7c 08 03 a6 mtlr r0
ffc0f1f8: 83 61 00 1c lwz r27,28(r1)
ffc0f1fc: 83 81 00 20 lwz r28,32(r1)
ffc0f200: 83 a1 00 24 lwz r29,36(r1)
ffc0f204: 83 c1 00 28 lwz r30,40(r1)
ffc0f208: 83 e1 00 2c lwz r31,44(r1)
ffc0f20c: 38 21 00 30 addi r1,r1,48
ffc0f210: 4e 80 00 20 blr
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
ffc0f214: 70 09 40 00 andi. r9,r0,16384
do_wait = wait;
/*
* Now perform the actual message receive
*/
msg_status = _CORE_message_queue_Submit(
ffc0f218: 7f ea fb 78 mr r10,r31
ffc0f21c: 7f 64 db 78 mr r4,r27
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
ffc0f220: 7d 20 00 26 mfcr r9
ffc0f224: 55 29 1f fe rlwinm r9,r9,3,31,31
do_wait = wait;
/*
* Now perform the actual message receive
*/
msg_status = _CORE_message_queue_Submit(
ffc0f228: 7f 85 e3 78 mr r5,r28
ffc0f22c: 7f a6 eb 78 mr r6,r29
ffc0f230: 38 e0 00 00 li r7,0
ffc0f234: 7d 1e 00 d0 neg r8,r30
ffc0f238: 38 6b 00 1c addi r3,r11,28
ffc0f23c: 48 00 2b 95 bl ffc11dd0 <_CORE_message_queue_Submit>
ffc0f240: 7c 7f 1b 78 mr r31,r3
_POSIX_Message_queue_Priority_to_core( msg_prio ),
do_wait,
timeout /* no timeout */
);
_Thread_Enable_dispatch();
ffc0f244: 48 00 50 b1 bl ffc142f4 <_Thread_Enable_dispatch>
* after it wakes up. The returned status is correct for
* non-blocking operations but if we blocked, then we need
* to look at the status in our TCB.
*/
if ( msg_status == CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT )
ffc0f248: 2f 9f 00 07 cmpwi cr7,r31,7
ffc0f24c: 40 9e ff 94 bne+ cr7,ffc0f1e0 <_POSIX_Message_queue_Send_support+0xb0>
msg_status = _Thread_Executing->Wait.return_code;
ffc0f250: 3d 20 00 00 lis r9,0
ffc0f254: 81 29 36 90 lwz r9,13968(r9)
ffc0f258: 83 e9 00 34 lwz r31,52(r9)
ffc0f25c: 4b ff ff 84 b ffc0f1e0 <_POSIX_Message_queue_Send_support+0xb0>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
ffc0f260: 48 00 d1 cd bl ffc1c42c <__errno>
ffc0f264: 38 00 00 09 li r0,9
ffc0f268: 90 03 00 00 stw r0,0(r3)
ffc0f26c: 38 60 ff ff li r3,-1
ffc0f270: 4b ff ff 7c b ffc0f1ec <_POSIX_Message_queue_Send_support+0xbc>
* Validate the priority.
* XXX - Do not validate msg_prio is not less than 0.
*/
if ( msg_prio > MQ_PRIO_MAX )
rtems_set_errno_and_return_minus_one( EINVAL );
ffc0f274: 48 00 d1 b9 bl ffc1c42c <__errno>
ffc0f278: 38 00 00 16 li r0,22
ffc0f27c: 90 03 00 00 stw r0,0(r3)
ffc0f280: 38 60 ff ff li r3,-1
ffc0f284: 4b ff ff 68 b ffc0f1ec <_POSIX_Message_queue_Send_support+0xbc>
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) {
_Thread_Enable_dispatch();
ffc0f288: 48 00 50 6d bl ffc142f4 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EBADF );
ffc0f28c: 48 00 d1 a1 bl ffc1c42c <__errno>
ffc0f290: 38 00 00 09 li r0,9
ffc0f294: 90 03 00 00 stw r0,0(r3)
ffc0f298: 38 60 ff ff li r3,-1
ffc0f29c: 4b ff ff 50 b ffc0f1ec <_POSIX_Message_queue_Send_support+0xbc>
msg_status = _Thread_Executing->Wait.return_code;
if ( !msg_status )
return msg_status;
rtems_set_errno_and_return_minus_one(
ffc0f2a0: 48 00 d1 8d bl ffc1c42c <__errno>
ffc0f2a4: 7c 7e 1b 78 mr r30,r3
ffc0f2a8: 7f e3 fb 78 mr r3,r31
ffc0f2ac: 48 00 01 a5 bl ffc0f450 <_POSIX_Message_queue_Translate_core_message_queue_return_code>
ffc0f2b0: 90 7e 00 00 stw r3,0(r30)
ffc0f2b4: 38 60 ff ff li r3,-1
ffc0f2b8: 4b ff ff 34 b ffc0f1ec <_POSIX_Message_queue_Send_support+0xbc>
ffc0fae0 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>:
#include <rtems/posix/pthread.h>
void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(
Thread_Control *the_thread
)
{
ffc0fae0: 7c 08 02 a6 mflr r0
ffc0fae4: 94 21 ff f8 stwu r1,-8(r1)
ffc0fae8: 90 01 00 0c stw r0,12(r1)
POSIX_API_Control *thread_support;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
ffc0faec: 81 23 01 34 lwz r9,308(r3)
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
ffc0faf0: 80 09 00 d8 lwz r0,216(r9)
ffc0faf4: 2f 80 00 00 cmpwi cr7,r0,0
ffc0faf8: 40 9e 00 10 bne- cr7,ffc0fb08 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x28><== NEVER TAKEN
ffc0fafc: 80 09 00 dc lwz r0,220(r9)
ffc0fb00: 2f 80 00 01 cmpwi cr7,r0,1
ffc0fb04: 41 9e 00 18 beq- cr7,ffc0fb1c <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x3c>
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
} else
_Thread_Enable_dispatch();
ffc0fb08: 4b ff c8 81 bl ffc0c388 <_Thread_Enable_dispatch>
}
ffc0fb0c: 80 01 00 0c lwz r0,12(r1)
ffc0fb10: 38 21 00 08 addi r1,r1,8
ffc0fb14: 7c 08 03 a6 mtlr r0
ffc0fb18: 4e 80 00 20 blr
POSIX_API_Control *thread_support;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
ffc0fb1c: 80 09 00 e0 lwz r0,224(r9)
ffc0fb20: 2f 80 00 00 cmpwi cr7,r0,0
ffc0fb24: 41 9e ff e4 beq+ cr7,ffc0fb08 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x28>
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
ffc0fb28: 3d 20 00 00 lis r9,0
ffc0fb2c: 81 69 28 14 lwz r11,10260(r9)
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
ffc0fb30: 38 80 ff ff li r4,-1
ffc0fb34: 38 0b ff ff addi r0,r11,-1
ffc0fb38: 90 09 28 14 stw r0,10260(r9)
return _Thread_Dispatch_disable_level;
ffc0fb3c: 80 09 28 14 lwz r0,10260(r9)
ffc0fb40: 48 00 08 7d bl ffc103bc <_POSIX_Thread_Exit>
ffc0fb44: 4b ff ff c8 b ffc0fb0c <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x2c>
ffc1137c <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
ffc1137c: 94 21 ff e0 stwu r1,-32(r1)
ffc11380: 7c 08 02 a6 mflr r0
ffc11384: 93 c1 00 18 stw r30,24(r1)
ffc11388: 7c 7e 1b 78 mr r30,r3
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
ffc1138c: 80 64 00 00 lwz r3,0(r4)
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
ffc11390: 93 61 00 0c stw r27,12(r1)
ffc11394: 7c db 33 78 mr r27,r6
ffc11398: 93 81 00 10 stw r28,16(r1)
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
return EINVAL;
ffc1139c: 3b 80 00 16 li r28,22
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
ffc113a0: 93 a1 00 14 stw r29,20(r1)
ffc113a4: 7c bd 2b 78 mr r29,r5
ffc113a8: 93 e1 00 1c stw r31,28(r1)
ffc113ac: 7c 9f 23 78 mr r31,r4
ffc113b0: 90 01 00 24 stw r0,36(r1)
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
ffc113b4: 4b ff ff a5 bl ffc11358 <_POSIX_Priority_Is_valid>
ffc113b8: 2f 83 00 00 cmpwi cr7,r3,0
ffc113bc: 40 9e 00 2c bne- cr7,ffc113e8 <_POSIX_Thread_Translate_sched_param+0x6c><== ALWAYS TAKEN
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
}
ffc113c0: 80 01 00 24 lwz r0,36(r1)
ffc113c4: 7f 83 e3 78 mr r3,r28
ffc113c8: 83 61 00 0c lwz r27,12(r1)
ffc113cc: 7c 08 03 a6 mtlr r0
ffc113d0: 83 81 00 10 lwz r28,16(r1)
ffc113d4: 83 a1 00 14 lwz r29,20(r1)
ffc113d8: 83 c1 00 18 lwz r30,24(r1)
ffc113dc: 83 e1 00 1c lwz r31,28(r1)
ffc113e0: 38 21 00 20 addi r1,r1,32
ffc113e4: 4e 80 00 20 blr
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
ffc113e8: 2f 9e 00 00 cmpwi cr7,r30,0
)
{
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
ffc113ec: 38 00 00 00 li r0,0
ffc113f0: 90 1d 00 00 stw r0,0(r29)
*budget_callout = NULL;
ffc113f4: 90 1b 00 00 stw r0,0(r27)
if ( policy == SCHED_OTHER ) {
ffc113f8: 41 9e 00 a4 beq- cr7,ffc1149c <_POSIX_Thread_Translate_sched_param+0x120>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
return 0;
}
if ( policy == SCHED_FIFO ) {
ffc113fc: 2f 9e 00 01 cmpwi cr7,r30,1
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
ffc11400: 3b 80 00 00 li r28,0
if ( policy == SCHED_OTHER ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
return 0;
}
if ( policy == SCHED_FIFO ) {
ffc11404: 41 be ff bc beq- cr7,ffc113c0 <_POSIX_Thread_Translate_sched_param+0x44>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
ffc11408: 2f 9e 00 02 cmpwi cr7,r30,2
ffc1140c: 41 9e 00 c4 beq- cr7,ffc114d0 <_POSIX_Thread_Translate_sched_param+0x154>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
return 0;
}
if ( policy == SCHED_SPORADIC ) {
ffc11410: 2f 9e 00 04 cmpwi cr7,r30,4
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
ffc11414: 3b 80 00 16 li r28,22
if ( policy == SCHED_RR ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
return 0;
}
if ( policy == SCHED_SPORADIC ) {
ffc11418: 40 9e ff a8 bne+ cr7,ffc113c0 <_POSIX_Thread_Translate_sched_param+0x44>
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
ffc1141c: 80 1f 00 08 lwz r0,8(r31)
ffc11420: 2f 80 00 00 cmpwi cr7,r0,0
ffc11424: 40 9e 00 10 bne- cr7,ffc11434 <_POSIX_Thread_Translate_sched_param+0xb8>
ffc11428: 80 1f 00 0c lwz r0,12(r31)
ffc1142c: 2f 80 00 00 cmpwi cr7,r0,0
ffc11430: 41 9e ff 90 beq+ cr7,ffc113c0 <_POSIX_Thread_Translate_sched_param+0x44>
(param->sched_ss_repl_period.tv_nsec == 0) )
return EINVAL;
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
ffc11434: 80 1f 00 10 lwz r0,16(r31)
ffc11438: 2f 80 00 00 cmpwi cr7,r0,0
ffc1143c: 40 9e 00 14 bne- cr7,ffc11450 <_POSIX_Thread_Translate_sched_param+0xd4>
ffc11440: 80 1f 00 14 lwz r0,20(r31)
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
ffc11444: 3b 80 00 16 li r28,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) &&
ffc11448: 2f 80 00 00 cmpwi cr7,r0,0
ffc1144c: 41 9e ff 74 beq+ cr7,ffc113c0 <_POSIX_Thread_Translate_sched_param+0x44>
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
ffc11450: 38 7f 00 08 addi r3,r31,8
ffc11454: 4b ff cf 09 bl ffc0e35c <_Timespec_To_ticks>
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
ffc11458: 3b 80 00 16 li r28,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 ) <
ffc1145c: 7c 7e 1b 78 mr r30,r3
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
ffc11460: 38 7f 00 10 addi r3,r31,16
ffc11464: 4b ff ce f9 bl ffc0e35c <_Timespec_To_ticks>
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
ffc11468: 7f 9e 18 40 cmplw cr7,r30,r3
ffc1146c: 41 9c ff 54 blt+ cr7,ffc113c0 <_POSIX_Thread_Translate_sched_param+0x44>
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) )
ffc11470: 80 7f 00 04 lwz r3,4(r31)
ffc11474: 4b ff fe e5 bl ffc11358 <_POSIX_Priority_Is_valid>
ffc11478: 2f 83 00 00 cmpwi cr7,r3,0
ffc1147c: 41 9e ff 44 beq+ cr7,ffc113c0 <_POSIX_Thread_Translate_sched_param+0x44>
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
ffc11480: 38 00 00 03 li r0,3
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
ffc11484: 3d 20 ff c1 lis r9,-63
return EINVAL;
if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) )
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
ffc11488: 90 1d 00 00 stw r0,0(r29)
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
ffc1148c: 38 09 97 7c addi r0,r9,-26756
return 0;
ffc11490: 3b 80 00 00 li r28,0
if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) )
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
ffc11494: 90 1b 00 00 stw r0,0(r27)
return 0;
ffc11498: 4b ff ff 28 b ffc113c0 <_POSIX_Thread_Translate_sched_param+0x44>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
ffc1149c: 38 00 00 01 li r0,1
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
}
ffc114a0: 83 61 00 0c lwz r27,12(r1)
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
ffc114a4: 90 1d 00 00 stw r0,0(r29)
return 0;
ffc114a8: 3b 80 00 00 li r28,0
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
}
ffc114ac: 7f 83 e3 78 mr r3,r28
ffc114b0: 80 01 00 24 lwz r0,36(r1)
ffc114b4: 83 81 00 10 lwz r28,16(r1)
ffc114b8: 7c 08 03 a6 mtlr r0
ffc114bc: 83 a1 00 14 lwz r29,20(r1)
ffc114c0: 83 c1 00 18 lwz r30,24(r1)
ffc114c4: 83 e1 00 1c lwz r31,28(r1)
ffc114c8: 38 21 00 20 addi r1,r1,32
ffc114cc: 4e 80 00 20 blr
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
ffc114d0: 93 dd 00 00 stw r30,0(r29)
return 0;
ffc114d4: 4b ff fe ec b ffc113c0 <_POSIX_Thread_Translate_sched_param+0x44>
ffc10274 <_POSIX_Threads_Delete_extension>:
*/
void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
ffc10274: 94 21 ff e8 stwu r1,-24(r1)
ffc10278: 7c 08 02 a6 mflr r0
api = deleted->API_Extensions[ THREAD_API_POSIX ];
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
ffc1027c: 7c 83 23 78 mr r3,r4
*/
void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
ffc10280: 93 81 00 08 stw r28,8(r1)
ffc10284: 93 a1 00 0c stw r29,12(r1)
ffc10288: 7c 9d 23 78 mr r29,r4
Thread_Control *the_thread;
POSIX_API_Control *api;
void **value_ptr;
api = deleted->API_Extensions[ THREAD_API_POSIX ];
ffc1028c: 83 84 01 34 lwz r28,308(r4)
*/
void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
ffc10290: 90 01 00 1c stw r0,28(r1)
ffc10294: 93 c1 00 10 stw r30,16(r1)
ffc10298: 93 e1 00 14 stw r31,20(r1)
api = deleted->API_Extensions[ THREAD_API_POSIX ];
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
ffc1029c: 48 00 2e f1 bl ffc1318c <_POSIX_Threads_cancel_run>
/*
* Run all the key destructors
*/
_POSIX_Keys_Run_destructors( deleted );
ffc102a0: 7f a3 eb 78 mr r3,r29
ffc102a4: 48 00 2f 85 bl ffc13228 <_POSIX_Keys_Run_destructors>
ffc102a8: 3b fc 00 44 addi r31,r28,68
/*
* Wakeup all the tasks which joined with this one
*/
value_ptr = (void **) deleted->Wait.return_argument;
ffc102ac: 83 dd 00 28 lwz r30,40(r29)
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
ffc102b0: 48 00 00 0c b ffc102bc <_POSIX_Threads_Delete_extension+0x48>
*(void **)the_thread->Wait.return_argument = value_ptr;
ffc102b4: 81 23 00 28 lwz r9,40(r3) <== NOT EXECUTED
ffc102b8: 93 c9 00 00 stw r30,0(r9) <== NOT EXECUTED
/*
* Wakeup all the tasks which joined with this one
*/
value_ptr = (void **) deleted->Wait.return_argument;
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
ffc102bc: 7f e3 fb 78 mr r3,r31
ffc102c0: 4b ff c6 69 bl ffc0c928 <_Thread_queue_Dequeue>
ffc102c4: 2c 03 00 00 cmpwi r3,0
ffc102c8: 40 82 ff ec bne+ ffc102b4 <_POSIX_Threads_Delete_extension+0x40><== NEVER TAKEN
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
ffc102cc: 80 1c 00 84 lwz r0,132(r28)
ffc102d0: 2f 80 00 04 cmpwi cr7,r0,4
ffc102d4: 41 9e 00 34 beq- cr7,ffc10308 <_POSIX_Threads_Delete_extension+0x94>
(void) _Watchdog_Remove( &api->Sporadic_timer );
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
ffc102d8: 38 00 00 00 li r0,0
ffc102dc: 90 1d 01 34 stw r0,308(r29)
_Workspace_Free( api );
ffc102e0: 7f 83 e3 78 mr r3,r28
ffc102e4: 4b ff d9 41 bl ffc0dc24 <_Workspace_Free>
}
ffc102e8: 80 01 00 1c lwz r0,28(r1)
ffc102ec: 83 81 00 08 lwz r28,8(r1)
ffc102f0: 7c 08 03 a6 mtlr r0
ffc102f4: 83 a1 00 0c lwz r29,12(r1)
ffc102f8: 83 c1 00 10 lwz r30,16(r1)
ffc102fc: 83 e1 00 14 lwz r31,20(r1)
ffc10300: 38 21 00 18 addi r1,r1,24
ffc10304: 4e 80 00 20 blr
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
ffc10308: 38 7c 00 a8 addi r3,r28,168
ffc1030c: 4b ff d6 b9 bl ffc0d9c4 <_Watchdog_Remove>
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
ffc10310: 38 00 00 00 li r0,0
ffc10314: 90 1d 01 34 stw r0,308(r29)
_Workspace_Free( api );
ffc10318: 7f 83 e3 78 mr r3,r28
ffc1031c: 4b ff d9 09 bl ffc0dc24 <_Workspace_Free>
}
ffc10320: 80 01 00 1c lwz r0,28(r1)
ffc10324: 83 81 00 08 lwz r28,8(r1)
ffc10328: 7c 08 03 a6 mtlr r0
ffc1032c: 83 a1 00 0c lwz r29,12(r1)
ffc10330: 83 c1 00 10 lwz r30,16(r1)
ffc10334: 83 e1 00 14 lwz r31,20(r1)
ffc10338: 38 21 00 18 addi r1,r1,24
ffc1033c: 4e 80 00 20 blr
ffc10230 <_POSIX_Threads_Exitted_extension>:
* This method is invoked each time a thread exits.
*/
void _POSIX_Threads_Exitted_extension(
Thread_Control *executing
)
{
ffc10230: 7c 08 02 a6 mflr r0
ffc10234: 94 21 ff f8 stwu r1,-8(r1)
ffc10238: 90 01 00 0c stw r0,12(r1)
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
ffc1023c: 88 03 00 08 lbz r0,8(r3)
ffc10240: 54 00 07 7e clrlwi r0,r0,29
/*
* If the executing thread was not created with the POSIX API, then this
* API do not get to define its exit behavior.
*/
if ( _Objects_Get_API( executing->Object.id ) == OBJECTS_POSIX_API )
ffc10244: 2f 80 00 03 cmpwi cr7,r0,3
ffc10248: 41 9e 00 14 beq- cr7,ffc1025c <_POSIX_Threads_Exitted_extension+0x2c>
pthread_exit( executing->Wait.return_argument );
}
ffc1024c: 80 01 00 0c lwz r0,12(r1)
ffc10250: 38 21 00 08 addi r1,r1,8
ffc10254: 7c 08 03 a6 mtlr r0
ffc10258: 4e 80 00 20 blr
/*
* If the executing thread was not created with the POSIX API, then this
* API do not get to define its exit behavior.
*/
if ( _Objects_Get_API( executing->Object.id ) == OBJECTS_POSIX_API )
pthread_exit( executing->Wait.return_argument );
ffc1025c: 80 63 00 28 lwz r3,40(r3)
ffc10260: 48 00 34 45 bl ffc136a4 <pthread_exit>
}
ffc10264: 80 01 00 0c lwz r0,12(r1) <== NOT EXECUTED
ffc10268: 38 21 00 08 addi r1,r1,8 <== NOT EXECUTED
ffc1026c: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc10270: 4e 80 00 20 blr <== NOT EXECUTED
ffc0935c <_POSIX_Threads_Initialize_user_threads_body>:
*
* Output parameters: NONE
*/
void _POSIX_Threads_Initialize_user_threads_body(void)
{
ffc0935c: 94 21 ff 98 stwu r1,-104(r1)
ffc09360: 7c 08 02 a6 mflr r0
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;
ffc09364: 3d 20 00 00 lis r9,0
*
* Output parameters: NONE
*/
void _POSIX_Threads_Initialize_user_threads_body(void)
{
ffc09368: 90 01 00 6c stw r0,108(r1)
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;
ffc0936c: 39 29 20 44 addi r9,r9,8260
*
* Output parameters: NONE
*/
void _POSIX_Threads_Initialize_user_threads_body(void)
{
ffc09370: 93 e1 00 64 stw r31,100(r1)
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;
ffc09374: 83 e9 00 34 lwz r31,52(r9)
*
* Output parameters: NONE
*/
void _POSIX_Threads_Initialize_user_threads_body(void)
{
ffc09378: 93 a1 00 5c stw r29,92(r1)
pthread_attr_t attr;
user_threads = Configuration_POSIX_API.User_initialization_threads_table;
maximum = Configuration_POSIX_API.number_of_initialization_threads;
if ( !user_threads || maximum == 0 )
ffc0937c: 2f 9f 00 00 cmpwi cr7,r31,0
*
* Output parameters: NONE
*/
void _POSIX_Threads_Initialize_user_threads_body(void)
{
ffc09380: 93 c1 00 60 stw r30,96(r1)
posix_initialization_threads_table *user_threads;
pthread_t thread_id;
pthread_attr_t attr;
user_threads = Configuration_POSIX_API.User_initialization_threads_table;
maximum = Configuration_POSIX_API.number_of_initialization_threads;
ffc09384: 83 a9 00 30 lwz r29,48(r9)
if ( !user_threads || maximum == 0 )
ffc09388: 41 9e 00 5c beq- cr7,ffc093e4 <_POSIX_Threads_Initialize_user_threads_body+0x88><== NEVER TAKEN
ffc0938c: 2f 9d 00 00 cmpwi cr7,r29,0
ffc09390: 41 9e 00 54 beq- cr7,ffc093e4 <_POSIX_Threads_Initialize_user_threads_body+0x88><== NEVER TAKEN
ffc09394: 3b c0 00 00 li r30,0
for ( index=0 ; index < maximum ; index++ ) {
/*
* There is no way for these calls to fail in this situation.
*/
(void) pthread_attr_init( &attr );
ffc09398: 38 61 00 0c addi r3,r1,12
ffc0939c: 48 00 81 3d bl ffc114d8 <pthread_attr_init>
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
ffc093a0: 38 80 00 02 li r4,2
ffc093a4: 38 61 00 0c addi r3,r1,12
ffc093a8: 48 00 81 71 bl ffc11518 <pthread_attr_setinheritsched>
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
ffc093ac: 80 9f 00 04 lwz r4,4(r31)
ffc093b0: 38 61 00 0c addi r3,r1,12
ffc093b4: 48 00 81 99 bl ffc1154c <pthread_attr_setstacksize>
status = pthread_create(
ffc093b8: 80 bf 00 00 lwz r5,0(r31)
ffc093bc: 38 61 00 08 addi r3,r1,8
ffc093c0: 38 81 00 0c addi r4,r1,12
ffc093c4: 38 c0 00 00 li r6,0
ffc093c8: 4b ff fb 3d bl ffc08f04 <pthread_create>
&thread_id,
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
ffc093cc: 7c 65 1b 79 mr. r5,r3
ffc093d0: 40 82 00 30 bne- ffc09400 <_POSIX_Threads_Initialize_user_threads_body+0xa4>
*
* Setting the attributes explicitly is critical, since we don't want
* to inherit the idle tasks attributes.
*/
for ( index=0 ; index < maximum ; index++ ) {
ffc093d4: 3b de 00 01 addi r30,r30,1
ffc093d8: 7f 9d f0 00 cmpw cr7,r29,r30
ffc093dc: 3b ff 00 08 addi r31,r31,8
ffc093e0: 40 9e ff b8 bne+ cr7,ffc09398 <_POSIX_Threads_Initialize_user_threads_body+0x3c><== NEVER TAKEN
NULL
);
if ( status )
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
}
}
ffc093e4: 80 01 00 6c lwz r0,108(r1)
ffc093e8: 83 a1 00 5c lwz r29,92(r1)
ffc093ec: 7c 08 03 a6 mtlr r0
ffc093f0: 83 c1 00 60 lwz r30,96(r1)
ffc093f4: 83 e1 00 64 lwz r31,100(r1)
ffc093f8: 38 21 00 68 addi r1,r1,104
ffc093fc: 4e 80 00 20 blr
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
ffc09400: 38 60 00 02 li r3,2
ffc09404: 38 80 00 01 li r4,1
ffc09408: 48 00 29 91 bl ffc0bd98 <_Internal_error_Occurred>
ffc104a4 <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
ffc104a4: 94 21 ff f0 stwu r1,-16(r1)
ffc104a8: 7c 08 02 a6 mflr r0
ffc104ac: 90 01 00 14 stw r0,20(r1)
ffc104b0: 93 e1 00 0c stw r31,12(r1)
Thread_Control *the_thread;
POSIX_API_Control *api;
the_thread = argument;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
ffc104b4: 83 e4 01 34 lwz r31,308(r4)
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
ffc104b8: 93 c1 00 08 stw r30,8(r1)
ffc104bc: 7c 9e 23 78 mr r30,r4
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 );
ffc104c0: 38 7f 00 98 addi r3,r31,152
ffc104c4: 48 00 12 7d bl ffc11740 <_Timespec_To_ticks>
*/
#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 ) {
ffc104c8: 80 1e 00 1c lwz r0,28(r30)
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
ffc104cc: 3d 20 00 00 lis r9,0
ffc104d0: 2f 80 00 00 cmpwi cr7,r0,0
ffc104d4: 88 89 27 24 lbz r4,10020(r9)
ffc104d8: 80 1f 00 88 lwz r0,136(r31)
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 );
the_thread->cpu_time_budget = ticks;
ffc104dc: 90 7e 00 78 stw r3,120(r30)
ffc104e0: 7c 80 20 50 subf r4,r0,r4
new_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority );
the_thread->real_priority = new_priority;
ffc104e4: 90 9e 00 18 stw r4,24(r30)
*/
#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 ) {
ffc104e8: 40 9e 00 10 bne- cr7,ffc104f8 <_POSIX_Threads_Sporadic_budget_TSR+0x54><== NEVER TAKEN
/*
* If this would make them less important, then do not change it.
*/
if ( the_thread->current_priority > new_priority ) {
ffc104ec: 80 1e 00 14 lwz r0,20(r30)
ffc104f0: 7f 80 20 40 cmplw cr7,r0,r4
ffc104f4: 41 9d 00 38 bgt- cr7,ffc1052c <_POSIX_Threads_Sporadic_budget_TSR+0x88>
#endif
}
}
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period );
ffc104f8: 38 7f 00 90 addi r3,r31,144
ffc104fc: 48 00 12 45 bl ffc11740 <_Timespec_To_ticks>
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
ffc10500: 38 9f 00 a8 addi r4,r31,168
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
ffc10504: 90 7f 00 b4 stw r3,180(r31)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
ffc10508: 3c 60 00 00 lis r3,0
ffc1050c: 38 63 2d 68 addi r3,r3,11624
ffc10510: 4b ff d2 ed bl ffc0d7fc <_Watchdog_Insert>
_Watchdog_Insert_ticks( &api->Sporadic_timer, ticks );
}
ffc10514: 80 01 00 14 lwz r0,20(r1)
ffc10518: 83 c1 00 08 lwz r30,8(r1)
ffc1051c: 7c 08 03 a6 mtlr r0
ffc10520: 83 e1 00 0c lwz r31,12(r1)
ffc10524: 38 21 00 10 addi r1,r1,16
ffc10528: 4e 80 00 20 blr
if ( the_thread->resource_count == 0 ) {
/*
* If this would make them less important, then do not change it.
*/
if ( the_thread->current_priority > new_priority ) {
_Thread_Change_priority( the_thread, new_priority, true );
ffc1052c: 7f c3 f3 78 mr r3,r30
ffc10530: 38 a0 00 01 li r5,1
ffc10534: 4b ff b9 91 bl ffc0bec4 <_Thread_Change_priority>
#endif
}
}
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period );
ffc10538: 38 7f 00 90 addi r3,r31,144
ffc1053c: 48 00 12 05 bl ffc11740 <_Timespec_To_ticks>
ffc10540: 38 9f 00 a8 addi r4,r31,168
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
ffc10544: 90 7f 00 b4 stw r3,180(r31)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
ffc10548: 3c 60 00 00 lis r3,0
ffc1054c: 38 63 2d 68 addi r3,r3,11624
ffc10550: 4b ff d2 ad bl ffc0d7fc <_Watchdog_Insert>
_Watchdog_Insert_ticks( &api->Sporadic_timer, ticks );
}
ffc10554: 80 01 00 14 lwz r0,20(r1)
ffc10558: 83 c1 00 08 lwz r30,8(r1)
ffc1055c: 7c 08 03 a6 mtlr r0
ffc10560: 83 e1 00 0c lwz r31,12(r1)
ffc10564: 38 21 00 10 addi r1,r1,16
ffc10568: 4e 80 00 20 blr
ffc1056c <_POSIX_Threads_Sporadic_budget_callout>:
* _POSIX_Threads_Sporadic_budget_callout
*/
void _POSIX_Threads_Sporadic_budget_callout(
Thread_Control *the_thread
)
{
ffc1056c: 7c 08 02 a6 mflr r0
ffc10570: 94 21 ff f8 stwu r1,-8(r1)
ffc10574: 90 01 00 0c stw r0,12(r1)
*/
#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 ) {
ffc10578: 80 03 00 1c lwz r0,28(r3)
)
{
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
ffc1057c: 81 63 01 34 lwz r11,308(r3)
*/
#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 ) {
ffc10580: 2f 80 00 00 cmpwi cr7,r0,0
ffc10584: 80 0b 00 8c lwz r0,140(r11)
ffc10588: 3d 60 00 00 lis r11,0
ffc1058c: 88 8b 27 24 lbz r4,10020(r11)
ffc10590: 7c 80 20 50 subf r4,r0,r4
/*
* 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 */
ffc10594: 38 00 ff ff li r0,-1
new_priority = _POSIX_Priority_To_core(api->schedparam.sched_ss_low_priority);
the_thread->real_priority = new_priority;
ffc10598: 90 83 00 18 stw r4,24(r3)
/*
* 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 */
ffc1059c: 90 03 00 78 stw r0,120(r3)
*/
#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 ) {
ffc105a0: 40 9e 00 10 bne- cr7,ffc105b0 <_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 ) {
ffc105a4: 80 03 00 14 lwz r0,20(r3)
ffc105a8: 7f 80 20 40 cmplw cr7,r0,r4
ffc105ac: 41 9c 00 14 blt- cr7,ffc105c0 <_POSIX_Threads_Sporadic_budget_callout+0x54><== ALWAYS TAKEN
#if 0
printk( "lower priority\n" );
#endif
}
}
}
ffc105b0: 80 01 00 0c lwz r0,12(r1) <== NOT EXECUTED
ffc105b4: 38 21 00 08 addi r1,r1,8 <== NOT EXECUTED
ffc105b8: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc105bc: 4e 80 00 20 blr <== NOT EXECUTED
* 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 ) {
_Thread_Change_priority( the_thread, new_priority, true );
ffc105c0: 38 a0 00 01 li r5,1
ffc105c4: 4b ff b9 01 bl ffc0bec4 <_Thread_Change_priority>
#if 0
printk( "lower priority\n" );
#endif
}
}
}
ffc105c8: 80 01 00 0c lwz r0,12(r1)
ffc105cc: 38 21 00 08 addi r1,r1,8
ffc105d0: 7c 08 03 a6 mtlr r0
ffc105d4: 4e 80 00 20 blr
ffc1318c <_POSIX_Threads_cancel_run>:
#include <rtems/posix/threadsup.h>
void _POSIX_Threads_cancel_run(
Thread_Control *the_thread
)
{
ffc1318c: 94 21 ff e8 stwu r1,-24(r1)
ffc13190: 7c 08 02 a6 mflr r0
ffc13194: 90 01 00 1c stw r0,28(r1)
ffc13198: 93 c1 00 10 stw r30,16(r1)
POSIX_Cancel_Handler_control *handler;
Chain_Control *handler_stack;
POSIX_API_Control *thread_support;
ISR_Level level;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
ffc1319c: 83 c3 01 34 lwz r30,308(r3)
#include <rtems/posix/threadsup.h>
void _POSIX_Threads_cancel_run(
Thread_Control *the_thread
)
{
ffc131a0: 93 a1 00 0c stw r29,12(r1)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
ffc131a4: 3b be 00 e8 addi r29,r30,232
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
while ( !_Chain_Is_empty( handler_stack ) ) {
ffc131a8: 80 1e 00 e4 lwz r0,228(r30)
#include <rtems/posix/threadsup.h>
void _POSIX_Threads_cancel_run(
Thread_Control *the_thread
)
{
ffc131ac: 93 e1 00 14 stw r31,20(r1)
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
while ( !_Chain_Is_empty( handler_stack ) ) {
ffc131b0: 7f 80 e8 00 cmpw cr7,r0,r29
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
ffc131b4: 38 00 00 01 li r0,1
ffc131b8: 90 1e 00 d8 stw r0,216(r30)
while ( !_Chain_Is_empty( handler_stack ) ) {
ffc131bc: 41 9e 00 50 beq- cr7,ffc1320c <_POSIX_Threads_cancel_run+0x80>
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc131c0: 7c 00 00 a6 mfmsr r0
ffc131c4: 7d 30 42 a6 mfsprg r9,0
ffc131c8: 7c 09 48 78 andc r9,r0,r9
ffc131cc: 7d 20 01 24 mtmsr r9
_ISR_Disable( level );
handler = (POSIX_Cancel_Handler_control *)
ffc131d0: 83 fe 00 ec lwz r31,236(r30)
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
ffc131d4: 81 7f 00 00 lwz r11,0(r31)
previous = the_node->previous;
ffc131d8: 81 3f 00 04 lwz r9,4(r31)
next->previous = previous;
ffc131dc: 91 2b 00 04 stw r9,4(r11)
previous->next = next;
ffc131e0: 91 69 00 00 stw r11,0(r9)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc131e4: 7c 00 01 24 mtmsr r0
_Chain_Tail( handler_stack )->previous;
_Chain_Extract_unprotected( &handler->Node );
_ISR_Enable( level );
(*handler->routine)( handler->arg );
ffc131e8: 80 1f 00 08 lwz r0,8(r31)
ffc131ec: 80 7f 00 0c lwz r3,12(r31)
ffc131f0: 7c 09 03 a6 mtctr r0
ffc131f4: 4e 80 04 21 bctrl
_Workspace_Free( handler );
ffc131f8: 7f e3 fb 78 mr r3,r31
ffc131fc: 4b ff aa 29 bl ffc0dc24 <_Workspace_Free>
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
while ( !_Chain_Is_empty( handler_stack ) ) {
ffc13200: 80 1e 00 e4 lwz r0,228(r30)
ffc13204: 7f 80 e8 00 cmpw cr7,r0,r29
ffc13208: 40 9e ff b8 bne+ cr7,ffc131c0 <_POSIX_Threads_cancel_run+0x34><== NEVER TAKEN
(*handler->routine)( handler->arg );
_Workspace_Free( handler );
}
}
ffc1320c: 80 01 00 1c lwz r0,28(r1)
ffc13210: 83 a1 00 0c lwz r29,12(r1)
ffc13214: 7c 08 03 a6 mtlr r0
ffc13218: 83 c1 00 10 lwz r30,16(r1)
ffc1321c: 83 e1 00 14 lwz r31,20(r1)
ffc13220: 38 21 00 18 addi r1,r1,24
ffc13224: 4e 80 00 20 blr
ffc090d8 <_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)
{
ffc090d8: 94 21 ff f0 stwu r1,-16(r1)
ffc090dc: 7c 08 02 a6 mflr r0
ffc090e0: 90 01 00 14 stw r0,20(r1)
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
ffc090e4: 80 04 00 54 lwz r0,84(r4)
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
ffc090e8: 81 24 00 68 lwz r9,104(r4)
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
ffc090ec: 2f 80 00 00 cmpwi cr7,r0,0
* This is the operation that is run when a timer expires
*/
void _POSIX_Timer_TSR(
Objects_Id timer __attribute__((unused)),
void *data)
{
ffc090f0: 93 e1 00 0c stw r31,12(r1)
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
ffc090f4: 38 09 00 01 addi r0,r9,1
* This is the operation that is run when a timer expires
*/
void _POSIX_Timer_TSR(
Objects_Id timer __attribute__((unused)),
void *data)
{
ffc090f8: 7c 9f 23 78 mr r31,r4
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
ffc090fc: 90 04 00 68 stw r0,104(r4)
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
ffc09100: 40 9e 00 40 bne- cr7,ffc09140 <_POSIX_Timer_TSR+0x68>
ffc09104: 80 04 00 58 lwz r0,88(r4)
ffc09108: 2f 80 00 00 cmpwi cr7,r0,0
ffc0910c: 40 9e 00 34 bne- cr7,ffc09140 <_POSIX_Timer_TSR+0x68> <== ALWAYS TAKEN
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
} else {
/* Indicates that the timer is stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
ffc09110: 38 00 00 04 li r0,4 <== NOT EXECUTED
ffc09114: 98 04 00 3c stb r0,60(r4) <== NOT EXECUTED
/*
* The sending of the signal to the process running the handling function
* specified for that signal is simulated
*/
if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) {
ffc09118: 80 7f 00 38 lwz r3,56(r31)
ffc0911c: 80 9f 00 44 lwz r4,68(r31)
ffc09120: 48 00 79 5d bl ffc10a7c <pthread_kill>
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
ffc09124: 38 00 00 00 li r0,0
ffc09128: 90 1f 00 68 stw r0,104(r31)
}
ffc0912c: 80 01 00 14 lwz r0,20(r1)
ffc09130: 83 e1 00 0c lwz r31,12(r1)
ffc09134: 38 21 00 10 addi r1,r1,16
ffc09138: 7c 08 03 a6 mtlr r0
ffc0913c: 4e 80 00 20 blr
ptimer->overrun = ptimer->overrun + 1;
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
ffc09140: 80 9f 00 64 lwz r4,100(r31)
ffc09144: 3c c0 ff c1 lis r6,-63
ffc09148: 80 bf 00 08 lwz r5,8(r31)
ffc0914c: 38 7f 00 10 addi r3,r31,16
ffc09150: 38 c6 90 d8 addi r6,r6,-28456
ffc09154: 7f e7 fb 78 mr r7,r31
ffc09158: 48 00 7f 31 bl ffc11088 <_POSIX_Timer_Insert_helper>
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
ffc0915c: 2f 83 00 00 cmpwi cr7,r3,0
ffc09160: 41 9e ff cc beq+ cr7,ffc0912c <_POSIX_Timer_TSR+0x54> <== NEVER TAKEN
return;
/* Store the time when the timer was started again */
_TOD_Get( &ptimer->time );
ffc09164: 38 7f 00 6c addi r3,r31,108
ffc09168: 48 00 1d e5 bl ffc0af4c <_TOD_Get>
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
ffc0916c: 38 00 00 03 li r0,3
ffc09170: 98 1f 00 3c stb r0,60(r31)
ffc09174: 4b ff ff a4 b ffc09118 <_POSIX_Timer_TSR+0x40>
ffc13308 <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
ffc13308: 94 21 ff 98 stwu r1,-104(r1)
ffc1330c: 7c 08 02 a6 mflr r0
ffc13310: 7c a6 2b 78 mr r6,r5
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,
ffc13314: 38 e0 00 01 li r7,1
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
ffc13318: 93 c1 00 60 stw r30,96(r1)
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,
ffc1331c: 38 a1 00 08 addi r5,r1,8
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
ffc13320: 93 e1 00 64 stw r31,100(r1)
ffc13324: 7c 9e 23 78 mr r30,r4
ffc13328: 7c 7f 1b 78 mr r31,r3
ffc1332c: 90 01 00 6c stw r0,108(r1)
ffc13330: 93 21 00 4c stw r25,76(r1)
ffc13334: 93 41 00 50 stw r26,80(r1)
ffc13338: 93 61 00 54 stw r27,84(r1)
ffc1333c: 93 81 00 58 stw r28,88(r1)
ffc13340: 93 a1 00 5c stw r29,92(r1)
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,
ffc13344: 48 00 00 cd bl ffc13410 <_POSIX_signals_Clear_signals>
ffc13348: 2f 83 00 00 cmpwi cr7,r3,0
is_global, true ) )
return false;
ffc1334c: 38 60 00 00 li r3,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,
ffc13350: 41 9e 00 80 beq- cr7,ffc133d0 <_POSIX_signals_Check_signal+0xc8>
#endif
/*
* Just to prevent sending a signal which is currently being ignored.
*/
if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN )
ffc13354: 1f 9e 00 0c mulli r28,r30,12
ffc13358: 3f 60 00 00 lis r27,0
ffc1335c: 3b 7b 31 c0 addi r27,r27,12736
ffc13360: 7d 3b e2 14 add r9,r27,r28
ffc13364: 83 a9 00 08 lwz r29,8(r9)
ffc13368: 2f 9d 00 01 cmpwi cr7,r29,1
ffc1336c: 41 9e 00 64 beq- cr7,ffc133d0 <_POSIX_signals_Check_signal+0xc8><== NEVER TAKEN
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
ffc13370: 83 5f 00 d0 lwz r26,208(r31)
/*
* 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,
ffc13374: 3f 20 00 00 lis r25,0
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
ffc13378: 80 09 00 04 lwz r0,4(r9)
/*
* 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,
ffc1337c: 3b 39 31 44 addi r25,r25,12612
ffc13380: 80 99 00 0c lwz r4,12(r25)
ffc13384: 38 61 00 14 addi r3,r1,20
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
ffc13388: 7c 00 d3 78 or r0,r0,r26
ffc1338c: 90 1f 00 d0 stw r0,208(r31)
/*
* 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,
ffc13390: 38 84 00 20 addi r4,r4,32
ffc13394: 38 a0 00 28 li r5,40
ffc13398: 48 00 17 31 bl ffc14ac8 <memcpy>
sizeof( Thread_Wait_information ));
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
ffc1339c: 7c 1b e0 2e lwzx r0,r27,r28
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
ffc133a0: 7f c3 f3 78 mr r3,r30
sizeof( Thread_Wait_information ));
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
ffc133a4: 2f 80 00 02 cmpwi cr7,r0,2
ffc133a8: 41 9e 00 54 beq- cr7,ffc133fc <_POSIX_signals_Check_signal+0xf4>
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
default:
(*_POSIX_signals_Vectors[ signo ].sa_handler)( signo );
ffc133ac: 7f a9 03 a6 mtctr r29
ffc133b0: 4e 80 04 21 bctrl
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
ffc133b4: 80 79 00 0c lwz r3,12(r25)
ffc133b8: 38 81 00 14 addi r4,r1,20
ffc133bc: 38 a0 00 28 li r5,40
ffc133c0: 38 63 00 20 addi r3,r3,32
ffc133c4: 48 00 17 05 bl ffc14ac8 <memcpy>
sizeof( Thread_Wait_information ));
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
ffc133c8: 93 5f 00 d0 stw r26,208(r31)
return true;
ffc133cc: 38 60 00 01 li r3,1
}
ffc133d0: 80 01 00 6c lwz r0,108(r1)
ffc133d4: 83 21 00 4c lwz r25,76(r1)
ffc133d8: 7c 08 03 a6 mtlr r0
ffc133dc: 83 41 00 50 lwz r26,80(r1)
ffc133e0: 83 61 00 54 lwz r27,84(r1)
ffc133e4: 83 81 00 58 lwz r28,88(r1)
ffc133e8: 83 a1 00 5c lwz r29,92(r1)
ffc133ec: 83 c1 00 60 lwz r30,96(r1)
ffc133f0: 83 e1 00 64 lwz r31,100(r1)
ffc133f4: 38 21 00 68 addi r1,r1,104
ffc133f8: 4e 80 00 20 blr
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
ffc133fc: 38 81 00 08 addi r4,r1,8
ffc13400: 7f a9 03 a6 mtctr r29
ffc13404: 38 a0 00 00 li r5,0
ffc13408: 4e 80 04 21 bctrl
signo,
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
ffc1340c: 4b ff ff a8 b ffc133b4 <_POSIX_signals_Check_signal+0xac>
ffc13d00 <_POSIX_signals_Clear_process_signals>:
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc13d00: 7d 60 00 a6 mfmsr r11
ffc13d04: 7c 10 42 a6 mfsprg r0,0
ffc13d08: 7d 60 00 78 andc r0,r11,r0
ffc13d0c: 7c 00 01 24 mtmsr r0
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
ffc13d10: 3d 20 00 00 lis r9,0
ffc13d14: 1c 03 00 0c mulli r0,r3,12
ffc13d18: 39 29 31 c0 addi r9,r9,12736
ffc13d1c: 7d 29 00 2e lwzx r9,r9,r0
ffc13d20: 2f 89 00 02 cmpwi cr7,r9,2
ffc13d24: 41 9e 00 28 beq- cr7,ffc13d4c <_POSIX_signals_Clear_process_signals+0x4c>
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
ffc13d28: 3d 20 00 00 lis r9,0
ffc13d2c: 80 09 28 50 lwz r0,10320(r9)
ffc13d30: 39 40 ff fe li r10,-2
ffc13d34: 38 63 ff ff addi r3,r3,-1
ffc13d38: 5d 43 18 3e rotlw r3,r10,r3
ffc13d3c: 7c 63 00 38 and r3,r3,r0
ffc13d40: 90 69 28 50 stw r3,10320(r9)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc13d44: 7d 60 01 24 mtmsr r11
}
_ISR_Enable( level );
}
ffc13d48: 4e 80 00 20 blr
ISR_Level level;
_ISR_Disable( level );
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
ffc13d4c: 3d 20 00 00 lis r9,0
ffc13d50: 39 29 33 b4 addi r9,r9,13236
ffc13d54: 7d 40 4a 14 add r10,r0,r9
ffc13d58: 7d 29 00 2e lwzx r9,r9,r0
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
ffc13d5c: 38 0a 00 04 addi r0,r10,4
ffc13d60: 7f 89 00 00 cmpw cr7,r9,r0
ffc13d64: 41 be ff c4 beq- cr7,ffc13d28 <_POSIX_signals_Clear_process_signals+0x28><== ALWAYS TAKEN
ffc13d68: 7d 60 01 24 mtmsr r11 <== NOT EXECUTED
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
}
_ISR_Enable( level );
}
ffc13d6c: 4e 80 00 20 blr <== NOT EXECUTED
ffc09d90 <_POSIX_signals_Get_lowest>:
ffc09d90: 38 00 00 05 li r0,5
ffc09d94: 7c 09 03 a6 mtctr r0
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
ffc09d98: 39 20 00 1b li r9,27
ffc09d9c: 39 60 00 01 li r11,1
#include <rtems/posix/psignal.h>
#include <rtems/seterr.h>
#include <rtems/posix/time.h>
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
ffc09da0: 38 09 ff ff addi r0,r9,-1
ffc09da4: 7d 60 00 30 slw r0,r11,r0
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
ffc09da8: 7c 0a 18 39 and. r10,r0,r3
ffc09dac: 40 82 00 38 bne- ffc09de4 <_POSIX_signals_Get_lowest+0x54><== NEVER TAKEN
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
ffc09db0: 39 29 00 01 addi r9,r9,1
ffc09db4: 42 00 ff ec bdnz+ ffc09da0 <_POSIX_signals_Get_lowest+0x10>
ffc09db8: 38 00 00 1a li r0,26
ffc09dbc: 39 20 00 01 li r9,1
ffc09dc0: 7c 09 03 a6 mtctr r0
ffc09dc4: 39 60 00 01 li r11,1
ffc09dc8: 48 00 00 0c b ffc09dd4 <_POSIX_signals_Get_lowest+0x44>
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
ffc09dcc: 39 29 00 01 addi r9,r9,1
ffc09dd0: 42 40 00 14 bdz- ffc09de4 <_POSIX_signals_Get_lowest+0x54>
#include <rtems/posix/psignal.h>
#include <rtems/seterr.h>
#include <rtems/posix/time.h>
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
ffc09dd4: 38 09 ff ff addi r0,r9,-1
ffc09dd8: 7d 60 00 30 slw r0,r11,r0
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
ffc09ddc: 7c 0a 18 39 and. r10,r0,r3
ffc09de0: 41 82 ff ec beq+ ffc09dcc <_POSIX_signals_Get_lowest+0x3c>
* a return 0. This routine will NOT be called unless a signal
* is pending in the set passed in.
*/
found_it:
return signo;
}
ffc09de4: 7d 23 4b 78 mr r3,r9
ffc09de8: 4e 80 00 20 blr
ffc0ff74 <_POSIX_signals_Post_switch_extension>:
*/
void _POSIX_signals_Post_switch_extension(
Thread_Control *the_thread
)
{
ffc0ff74: 94 21 ff e0 stwu r1,-32(r1)
ffc0ff78: 7c 08 02 a6 mflr r0
ffc0ff7c: 90 01 00 24 stw r0,36(r1)
ffc0ff80: 93 c1 00 18 stw r30,24(r1)
POSIX_API_Control *api;
int signo;
ISR_Level level;
int hold_errno;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
ffc0ff84: 83 c3 01 34 lwz r30,308(r3)
*/
void _POSIX_signals_Post_switch_extension(
Thread_Control *the_thread
)
{
ffc0ff88: 93 81 00 10 stw r28,16(r1)
/*
* We need to ensure that if the signal handler executes a call
* which overwrites the unblocking status, we restore it.
*/
hold_errno = _Thread_Executing->Wait.return_code;
ffc0ff8c: 3f 80 00 00 lis r28,0
/*
* api may be NULL in case of a thread close in progress
*/
if ( !api )
ffc0ff90: 2f 9e 00 00 cmpwi cr7,r30,0
/*
* We need to ensure that if the signal handler executes a call
* which overwrites the unblocking status, we restore it.
*/
hold_errno = _Thread_Executing->Wait.return_code;
ffc0ff94: 3b 9c 31 44 addi r28,r28,12612
*/
void _POSIX_signals_Post_switch_extension(
Thread_Control *the_thread
)
{
ffc0ff98: 93 61 00 0c stw r27,12(r1)
/*
* We need to ensure that if the signal handler executes a call
* which overwrites the unblocking status, we restore it.
*/
hold_errno = _Thread_Executing->Wait.return_code;
ffc0ff9c: 81 3c 00 0c lwz r9,12(r28)
*/
void _POSIX_signals_Post_switch_extension(
Thread_Control *the_thread
)
{
ffc0ffa0: 93 a1 00 14 stw r29,20(r1)
ffc0ffa4: 93 e1 00 1c stw r31,28(r1)
/*
* We need to ensure that if the signal handler executes a call
* which overwrites the unblocking status, we restore it.
*/
hold_errno = _Thread_Executing->Wait.return_code;
ffc0ffa8: 83 69 00 34 lwz r27,52(r9)
/*
* api may be NULL in case of a thread close in progress
*/
if ( !api )
ffc0ffac: 41 9e 00 cc beq- cr7,ffc10078 <_POSIX_signals_Post_switch_extension+0x104>
ffc0ffb0: 3f a0 00 00 lis r29,0
ffc0ffb4: 3b bd 28 50 addi r29,r29,10320
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0ffb8: 7c 00 00 a6 mfmsr r0
ffc0ffbc: 7d 30 42 a6 mfsprg r9,0
ffc0ffc0: 7c 09 48 78 andc r9,r0,r9
ffc0ffc4: 7d 20 01 24 mtmsr r9
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
if ( !(~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending)) ) {
ffc0ffc8: 81 5d 00 00 lwz r10,0(r29)
ffc0ffcc: 81 3e 00 d4 lwz r9,212(r30)
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
if ( !(~api->signals_blocked &
ffc0ffd0: 81 7e 00 d0 lwz r11,208(r30)
(api->signals_pending | _POSIX_signals_Pending)) ) {
ffc0ffd4: 7d 49 4b 78 or r9,r10,r9
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0ffd8: 7c 00 01 24 mtmsr r0
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
if ( !(~api->signals_blocked &
ffc0ffdc: 7d 2a 58 79 andc. r10,r9,r11
ffc0ffe0: 41 82 00 90 beq- ffc10070 <_POSIX_signals_Post_switch_extension+0xfc>
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
ffc0ffe4: 3b e0 00 1b li r31,27
_POSIX_signals_Check_signal( api, signo, false );
ffc0ffe8: 7f e4 fb 78 mr r4,r31
ffc0ffec: 38 a0 00 00 li r5,0
ffc0fff0: 7f c3 f3 78 mr r3,r30
ffc0fff4: 48 00 33 15 bl ffc13308 <_POSIX_signals_Check_signal>
_POSIX_signals_Check_signal( api, signo, true );
ffc0fff8: 7f e4 fb 78 mr r4,r31
ffc0fffc: 7f c3 f3 78 mr r3,r30
ffc10000: 38 a0 00 01 li r5,1
ffc10004: 48 00 33 05 bl ffc13308 <_POSIX_signals_Check_signal>
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
ffc10008: 2f 9f 00 1f cmpwi cr7,r31,31
ffc1000c: 3b ff 00 01 addi r31,r31,1
ffc10010: 40 9e ff d8 bne+ cr7,ffc0ffe8 <_POSIX_signals_Post_switch_extension+0x74>
ffc10014: 3b e0 00 01 li r31,1
_POSIX_signals_Check_signal( api, signo, true );
}
/* Unfortunately - nothing like __SIGFIRSTNOTRT in newlib signal .h */
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
_POSIX_signals_Check_signal( api, signo, false );
ffc10018: 7f e4 fb 78 mr r4,r31
ffc1001c: 38 a0 00 00 li r5,0
ffc10020: 7f c3 f3 78 mr r3,r30
ffc10024: 48 00 32 e5 bl ffc13308 <_POSIX_signals_Check_signal>
_POSIX_signals_Check_signal( api, signo, true );
ffc10028: 7f e4 fb 78 mr r4,r31
ffc1002c: 7f c3 f3 78 mr r3,r30
ffc10030: 38 a0 00 01 li r5,1
ffc10034: 48 00 32 d5 bl ffc13308 <_POSIX_signals_Check_signal>
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
}
/* Unfortunately - nothing like __SIGFIRSTNOTRT in newlib signal .h */
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
ffc10038: 2f 9f 00 1a cmpwi cr7,r31,26
ffc1003c: 3b ff 00 01 addi r31,r31,1
ffc10040: 40 9e ff d8 bne+ cr7,ffc10018 <_POSIX_signals_Post_switch_extension+0xa4>
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc10044: 7c 00 00 a6 mfmsr r0
ffc10048: 7d 30 42 a6 mfsprg r9,0
ffc1004c: 7c 09 48 78 andc r9,r0,r9
ffc10050: 7d 20 01 24 mtmsr r9
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
if ( !(~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending)) ) {
ffc10054: 81 5d 00 00 lwz r10,0(r29)
ffc10058: 81 3e 00 d4 lwz r9,212(r30)
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
if ( !(~api->signals_blocked &
ffc1005c: 81 7e 00 d0 lwz r11,208(r30)
(api->signals_pending | _POSIX_signals_Pending)) ) {
ffc10060: 7d 49 4b 78 or r9,r10,r9
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc10064: 7c 00 01 24 mtmsr r0
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
if ( !(~api->signals_blocked &
ffc10068: 7d 2a 58 79 andc. r10,r9,r11
ffc1006c: 40 82 ff 78 bne+ ffc0ffe4 <_POSIX_signals_Post_switch_extension+0x70><== NEVER TAKEN
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
}
}
_Thread_Executing->Wait.return_code = hold_errno;
ffc10070: 81 3c 00 0c lwz r9,12(r28)
ffc10074: 93 69 00 34 stw r27,52(r9)
}
ffc10078: 80 01 00 24 lwz r0,36(r1)
ffc1007c: 83 61 00 0c lwz r27,12(r1)
ffc10080: 7c 08 03 a6 mtlr r0
ffc10084: 83 81 00 10 lwz r28,16(r1)
ffc10088: 83 a1 00 14 lwz r29,20(r1)
ffc1008c: 83 c1 00 18 lwz r30,24(r1)
ffc10090: 83 e1 00 1c lwz r31,28(r1)
ffc10094: 38 21 00 20 addi r1,r1,32
ffc10098: 4e 80 00 20 blr
ffc1f298 <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
ffc1f298: 94 21 ff f0 stwu r1,-16(r1)
ffc1f29c: 7c 08 02 a6 mflr r0
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
ffc1f2a0: 3d 20 10 00 lis r9,4096
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
ffc1f2a4: 90 01 00 14 stw r0,20(r1)
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
ffc1f2a8: 61 29 80 00 ori r9,r9,32768
ffc1f2ac: 80 03 00 10 lwz r0,16(r3)
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
ffc1f2b0: 93 e1 00 0c stw r31,12(r1)
ffc1f2b4: 7c 7f 1b 78 mr r31,r3
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
ffc1f2b8: 7c 0b 48 38 and r11,r0,r9
ffc1f2bc: 7f 8b 48 00 cmpw cr7,r11,r9
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
ffc1f2c0: 93 c1 00 08 stw r30,8(r1)
ffc1f2c4: 39 64 ff ff addi r11,r4,-1
ffc1f2c8: 39 20 00 01 li r9,1
POSIX_API_Control *api;
sigset_t mask;
siginfo_t *the_info = NULL;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
ffc1f2cc: 81 43 01 34 lwz r10,308(r3)
ffc1f2d0: 7d 2b 58 30 slw r11,r9,r11
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
ffc1f2d4: 41 9e 00 70 beq- cr7,ffc1f344 <_POSIX_signals_Unblock_thread+0xac>
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
ffc1f2d8: 81 4a 00 d0 lwz r10,208(r10)
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
ffc1f2dc: 3b c0 00 00 li r30,0
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
ffc1f2e0: 7d 68 50 79 andc. r8,r11,r10
ffc1f2e4: 41 82 00 44 beq- ffc1f328 <_POSIX_signals_Unblock_thread+0x90>
* 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 ) ) {
ffc1f2e8: 74 0b 10 00 andis. r11,r0,4096
ffc1f2ec: 41 82 00 b8 beq- ffc1f3a4 <_POSIX_signals_Unblock_thread+0x10c>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
ffc1f2f0: 3d 20 00 03 lis r9,3
ffc1f2f4: 61 29 be e0 ori r9,r9,48864
the_thread->Wait.return_code = EINTR;
/*
* 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) )
ffc1f2f8: 7c 08 48 39 and. r8,r0,r9
* we need to dispatch at the end of this ISR.
* + Any other combination, do nothing.
*/
if ( _States_Is_interruptible_by_signal( the_thread->current_state ) ) {
the_thread->Wait.return_code = EINTR;
ffc1f2fc: 39 20 00 04 li r9,4
ffc1f300: 91 23 00 34 stw r9,52(r3)
/*
* 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) )
ffc1f304: 40 82 00 e4 bne- ffc1f3e8 <_POSIX_signals_Unblock_thread+0x150>
_Thread_queue_Extract_with_proxy( the_thread );
else if ( _States_Is_delaying(the_thread->current_state) ) {
ffc1f308: 70 09 00 08 andi. r9,r0,8
ffc1f30c: 41 a2 00 1c beq+ ffc1f328 <_POSIX_signals_Unblock_thread+0x90><== NEVER TAKEN
(void) _Watchdog_Remove( &the_thread->Timer );
ffc1f310: 38 63 00 48 addi r3,r3,72
ffc1f314: 4b fe e6 b1 bl ffc0d9c4 <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
ffc1f318: 3c 80 10 03 lis r4,4099
ffc1f31c: 7f e3 fb 78 mr r3,r31
ffc1f320: 60 84 ff f8 ori r4,r4,65528
ffc1f324: 4b fe cd 3d bl ffc0c060 <_Thread_Clear_state>
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
}
ffc1f328: 80 01 00 14 lwz r0,20(r1)
ffc1f32c: 7f c3 f3 78 mr r3,r30
ffc1f330: 83 e1 00 0c lwz r31,12(r1)
ffc1f334: 7c 08 03 a6 mtlr r0
ffc1f338: 83 c1 00 08 lwz r30,8(r1)
ffc1f33c: 38 21 00 10 addi r1,r1,16
ffc1f340: 4e 80 00 20 blr
* 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) ) {
ffc1f344: 80 03 00 30 lwz r0,48(r3)
ffc1f348: 7d 68 00 39 and. r8,r11,r0
ffc1f34c: 41 82 00 88 beq- ffc1f3d4 <_POSIX_signals_Unblock_thread+0x13c>
the_thread->Wait.return_code = EINTR;
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
ffc1f350: 2f 85 00 00 cmpwi cr7,r5,0
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
the_thread->Wait.return_code = EINTR;
the_info = (siginfo_t *) the_thread->Wait.return_argument;
ffc1f354: 81 3f 00 28 lwz r9,40(r31)
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
the_thread->Wait.return_code = EINTR;
ffc1f358: 38 00 00 04 li r0,4
ffc1f35c: 90 1f 00 34 stw r0,52(r31)
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
ffc1f360: 41 9e 00 90 beq- cr7,ffc1f3f0 <_POSIX_signals_Unblock_thread+0x158>
the_info->si_signo = signo;
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
} else {
*the_info = *info;
ffc1f364: 81 45 00 00 lwz r10,0(r5)
ffc1f368: 81 65 00 04 lwz r11,4(r5)
ffc1f36c: 80 05 00 08 lwz r0,8(r5)
ffc1f370: 91 49 00 00 stw r10,0(r9)
ffc1f374: 91 69 00 04 stw r11,4(r9)
ffc1f378: 90 09 00 08 stw r0,8(r9)
}
_Thread_queue_Extract_with_proxy( the_thread );
ffc1f37c: 7f e3 fb 78 mr r3,r31
ffc1f380: 4b fe da 49 bl ffc0cdc8 <_Thread_queue_Extract_with_proxy>
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
}
ffc1f384: 80 01 00 14 lwz r0,20(r1)
} else {
*the_info = *info;
}
_Thread_queue_Extract_with_proxy( the_thread );
return true;
ffc1f388: 3b c0 00 01 li r30,1
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
}
ffc1f38c: 83 e1 00 0c lwz r31,12(r1)
ffc1f390: 7c 08 03 a6 mtlr r0
ffc1f394: 7f c3 f3 78 mr r3,r30
ffc1f398: 83 c1 00 08 lwz r30,8(r1)
ffc1f39c: 38 21 00 10 addi r1,r1,16
ffc1f3a0: 4e 80 00 20 blr
else if ( _States_Is_delaying(the_thread->current_state) ) {
(void) _Watchdog_Remove( &the_thread->Timer );
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
ffc1f3a4: 2f 80 00 00 cmpwi cr7,r0,0
ffc1f3a8: 40 be ff 80 bne- cr7,ffc1f328 <_POSIX_signals_Unblock_thread+0x90><== NEVER TAKEN
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
ffc1f3ac: 3d 60 00 00 lis r11,0
ffc1f3b0: 39 6b 31 44 addi r11,r11,12612
ffc1f3b4: 80 0b 00 08 lwz r0,8(r11)
ffc1f3b8: 2f 80 00 00 cmpwi cr7,r0,0
ffc1f3bc: 41 be ff 6c beq- cr7,ffc1f328 <_POSIX_signals_Unblock_thread+0x90>
ffc1f3c0: 80 0b 00 0c lwz r0,12(r11)
ffc1f3c4: 7f 83 00 00 cmpw cr7,r3,r0
ffc1f3c8: 40 9e ff 60 bne+ cr7,ffc1f328 <_POSIX_signals_Unblock_thread+0x90><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
ffc1f3cc: 99 2b 00 18 stb r9,24(r11)
ffc1f3d0: 4b ff ff 58 b ffc1f328 <_POSIX_signals_Unblock_thread+0x90>
* 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) ) {
ffc1f3d4: 80 0a 00 d0 lwz r0,208(r10)
/*
* This should only be reached via pthread_kill().
*/
return false;
ffc1f3d8: 3b c0 00 00 li r30,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) ) {
ffc1f3dc: 7d 69 00 79 andc. r9,r11,r0
ffc1f3e0: 40 82 ff 70 bne+ ffc1f350 <_POSIX_signals_Unblock_thread+0xb8>
ffc1f3e4: 4b ff ff 44 b ffc1f328 <_POSIX_signals_Unblock_thread+0x90>
/*
* In pthread_cond_wait, a thread will be blocking on a thread
* queue, but is also interruptible by a POSIX signal.
*/
if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
_Thread_queue_Extract_with_proxy( the_thread );
ffc1f3e8: 4b fe d9 e1 bl ffc0cdc8 <_Thread_queue_Extract_with_proxy>
ffc1f3ec: 4b ff ff 3c b ffc1f328 <_POSIX_signals_Unblock_thread+0x90>
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
the_info->si_signo = signo;
the_info->si_code = SI_USER;
ffc1f3f0: 38 00 00 01 li r0,1
the_thread->Wait.return_code = EINTR;
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
the_info->si_signo = signo;
ffc1f3f4: 90 89 00 00 stw r4,0(r9)
the_info->si_code = SI_USER;
ffc1f3f8: 90 09 00 04 stw r0,4(r9)
the_info->si_value.sival_int = 0;
ffc1f3fc: 90 a9 00 08 stw r5,8(r9)
ffc1f400: 4b ff ff 7c b ffc1f37c <_POSIX_signals_Unblock_thread+0xe4>
ffc12360 <_RBTree_Extract_unprotected>:
*/
void _RBTree_Extract_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
ffc12360: 94 21 ff e8 stwu r1,-24(r1)
ffc12364: 7c 08 02 a6 mflr r0
ffc12368: 93 c1 00 10 stw r30,16(r1)
RBTree_Node *leaf, *target;
RBTree_Color victim_color;
RBTree_Direction dir;
if (!the_node) return;
ffc1236c: 7c 9e 23 79 mr. r30,r4
*/
void _RBTree_Extract_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
ffc12370: 93 81 00 08 stw r28,8(r1)
ffc12374: 7c 7c 1b 78 mr r28,r3
ffc12378: 90 01 00 1c stw r0,28(r1)
ffc1237c: 93 a1 00 0c stw r29,12(r1)
ffc12380: 93 e1 00 14 stw r31,20(r1)
RBTree_Node *leaf, *target;
RBTree_Color victim_color;
RBTree_Direction dir;
if (!the_node) return;
ffc12384: 41 82 01 10 beq- ffc12494 <_RBTree_Extract_unprotected+0x134>
/* check if min needs to be updated */
if (the_node == the_rbtree->first[RBT_LEFT]) {
ffc12388: 80 03 00 08 lwz r0,8(r3)
ffc1238c: 7f 80 f0 00 cmpw cr7,r0,r30
ffc12390: 41 9e 01 68 beq- cr7,ffc124f8 <_RBTree_Extract_unprotected+0x198>
the_rbtree->first[RBT_LEFT]))
the_rbtree->first[RBT_LEFT] = NULL;
}
}
/* check if max needs to be updated: note, min can equal max (1 element) */
if (the_node == the_rbtree->first[RBT_RIGHT]) {
ffc12394: 80 1c 00 0c lwz r0,12(r28)
ffc12398: 7f 80 f0 00 cmpw cr7,r0,r30
ffc1239c: 41 9e 01 28 beq- cr7,ffc124c4 <_RBTree_Extract_unprotected+0x164>
* either max in node->child[RBT_LEFT] or min in node->child[RBT_RIGHT],
* and replace the_node with the target node. This maintains the binary
* search tree property, but may violate the red-black properties.
*/
if (the_node->child[RBT_LEFT] && the_node->child[RBT_RIGHT]) {
ffc123a0: 83 fe 00 04 lwz r31,4(r30)
ffc123a4: 2f 9f 00 00 cmpwi cr7,r31,0
ffc123a8: 41 9e 01 38 beq- cr7,ffc124e0 <_RBTree_Extract_unprotected+0x180>
ffc123ac: 80 1e 00 08 lwz r0,8(r30)
ffc123b0: 2f 80 00 00 cmpwi cr7,r0,0
ffc123b4: 40 be 00 0c bne+ cr7,ffc123c0 <_RBTree_Extract_unprotected+0x60>
ffc123b8: 48 00 01 54 b ffc1250c <_RBTree_Extract_unprotected+0x1ac>
target = the_node->child[RBT_LEFT]; /* find max in node->child[RBT_LEFT] */
while (target->child[RBT_RIGHT]) target = target->child[RBT_RIGHT];
ffc123bc: 7c 1f 03 78 mr r31,r0
ffc123c0: 80 1f 00 08 lwz r0,8(r31)
ffc123c4: 2f 80 00 00 cmpwi cr7,r0,0
ffc123c8: 40 9e ff f4 bne+ cr7,ffc123bc <_RBTree_Extract_unprotected+0x5c>
* target's position (target is the right child of target->parent)
* when target vacates it. if there is no child, then target->parent
* should become NULL. This may cause the coloring to be violated.
* For now we store the color of the node being deleted in victim_color.
*/
leaf = target->child[RBT_LEFT];
ffc123cc: 83 bf 00 04 lwz r29,4(r31)
if(leaf) {
ffc123d0: 2f 9d 00 00 cmpwi cr7,r29,0
ffc123d4: 41 9e 01 a0 beq- cr7,ffc12574 <_RBTree_Extract_unprotected+0x214>
leaf->parent = target->parent;
ffc123d8: 80 1f 00 00 lwz r0,0(r31)
ffc123dc: 90 1d 00 00 stw r0,0(r29)
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
}
victim_color = target->color;
dir = target != target->parent->child[0];
ffc123e0: 81 5f 00 00 lwz r10,0(r31)
target->parent->child[dir] = leaf;
/* now replace the_node with target */
dir = the_node != the_node->parent->child[0];
ffc123e4: 81 7e 00 00 lwz r11,0(r30)
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
}
victim_color = target->color;
dir = target != target->parent->child[0];
ffc123e8: 80 0a 00 04 lwz r0,4(r10)
leaf->parent = target->parent;
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
}
victim_color = target->color;
ffc123ec: 81 3f 00 0c lwz r9,12(r31)
dir = target != target->parent->child[0];
ffc123f0: 7f e0 02 78 xor r0,r31,r0
ffc123f4: 7c 00 00 34 cntlzw r0,r0
ffc123f8: 54 00 d9 7e rlwinm r0,r0,27,5,31
ffc123fc: 68 00 00 01 xori r0,r0,1
target->parent->child[dir] = leaf;
ffc12400: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc12404: 7d 4a 02 14 add r10,r10,r0
ffc12408: 93 aa 00 04 stw r29,4(r10)
/* now replace the_node with target */
dir = the_node != the_node->parent->child[0];
ffc1240c: 80 0b 00 04 lwz r0,4(r11)
ffc12410: 7f c0 02 78 xor r0,r30,r0
ffc12414: 7c 00 00 34 cntlzw r0,r0
ffc12418: 54 00 d9 7e rlwinm r0,r0,27,5,31
ffc1241c: 68 00 00 01 xori r0,r0,1
the_node->parent->child[dir] = target;
ffc12420: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc12424: 7d 6b 02 14 add r11,r11,r0
ffc12428: 93 eb 00 04 stw r31,4(r11)
/* set target's new children to the original node's children */
target->child[RBT_RIGHT] = the_node->child[RBT_RIGHT];
ffc1242c: 80 1e 00 08 lwz r0,8(r30)
ffc12430: 90 1f 00 08 stw r0,8(r31)
if (the_node->child[RBT_RIGHT])
ffc12434: 81 7e 00 08 lwz r11,8(r30)
ffc12438: 2f 8b 00 00 cmpwi cr7,r11,0
ffc1243c: 41 9e 00 08 beq- cr7,ffc12444 <_RBTree_Extract_unprotected+0xe4><== NEVER TAKEN
the_node->child[RBT_RIGHT]->parent = target;
ffc12440: 93 eb 00 00 stw r31,0(r11)
target->child[RBT_LEFT] = the_node->child[RBT_LEFT];
ffc12444: 80 1e 00 04 lwz r0,4(r30)
ffc12448: 90 1f 00 04 stw r0,4(r31)
if (the_node->child[RBT_LEFT])
ffc1244c: 81 7e 00 04 lwz r11,4(r30)
ffc12450: 2f 8b 00 00 cmpwi cr7,r11,0
ffc12454: 41 9e 00 08 beq- cr7,ffc1245c <_RBTree_Extract_unprotected+0xfc>
the_node->child[RBT_LEFT]->parent = target;
ffc12458: 93 eb 00 00 stw r31,0(r11)
/* finally, update the parent node and recolor. target has completely
* replaced the_node, and target's child has moved up the tree if needed.
* the_node is no longer part of the tree, although it has valid pointers
* still.
*/
target->parent = the_node->parent;
ffc1245c: 81 7e 00 00 lwz r11,0(r30)
target->color = the_node->color;
ffc12460: 80 1e 00 0c lwz r0,12(r30)
/* finally, update the parent node and recolor. target has completely
* replaced the_node, and target's child has moved up the tree if needed.
* the_node is no longer part of the tree, although it has valid pointers
* still.
*/
target->parent = the_node->parent;
ffc12464: 91 7f 00 00 stw r11,0(r31)
target->color = the_node->color;
ffc12468: 90 1f 00 0c stw r0,12(r31)
/* fix coloring. leaf has moved up the tree. The color of the deleted
* node is in victim_color. There are two cases:
* 1. Deleted a red node, its child must be black. Nothing must be done.
* 2. Deleted a black node, its child must be red. Paint child black.
*/
if (victim_color == RBT_BLACK) { /* eliminate case 1 */
ffc1246c: 2f 89 00 00 cmpwi cr7,r9,0
ffc12470: 41 9e 00 44 beq- cr7,ffc124b4 <_RBTree_Extract_unprotected+0x154>
/* Wipe the_node */
_RBTree_Set_off_rbtree(the_node);
/* set root to black, if it exists */
if (the_rbtree->root) the_rbtree->root->color = RBT_BLACK;
ffc12474: 81 3c 00 04 lwz r9,4(r28)
*/
RTEMS_INLINE_ROUTINE void _RBTree_Set_off_rbtree(
RBTree_Node *node
)
{
node->parent = node->child[RBT_LEFT] = node->child[RBT_RIGHT] = NULL;
ffc12478: 38 00 00 00 li r0,0
ffc1247c: 90 1e 00 08 stw r0,8(r30)
ffc12480: 2f 89 00 00 cmpwi cr7,r9,0
ffc12484: 90 1e 00 04 stw r0,4(r30)
ffc12488: 90 1e 00 00 stw r0,0(r30)
ffc1248c: 41 9e 00 08 beq- cr7,ffc12494 <_RBTree_Extract_unprotected+0x134>
ffc12490: 90 09 00 0c stw r0,12(r9)
}
ffc12494: 80 01 00 1c lwz r0,28(r1)
ffc12498: 83 81 00 08 lwz r28,8(r1)
ffc1249c: 7c 08 03 a6 mtlr r0
ffc124a0: 83 a1 00 0c lwz r29,12(r1)
ffc124a4: 83 c1 00 10 lwz r30,16(r1)
ffc124a8: 83 e1 00 14 lwz r31,20(r1)
ffc124ac: 38 21 00 18 addi r1,r1,24
ffc124b0: 4e 80 00 20 blr
* node is in victim_color. There are two cases:
* 1. Deleted a red node, its child must be black. Nothing must be done.
* 2. Deleted a black node, its child must be red. Paint child black.
*/
if (victim_color == RBT_BLACK) { /* eliminate case 1 */
if (leaf) {
ffc124b4: 2f 9d 00 00 cmpwi cr7,r29,0
ffc124b8: 41 be ff bc beq- cr7,ffc12474 <_RBTree_Extract_unprotected+0x114>
leaf->color = RBT_BLACK; /* case 2 */
ffc124bc: 91 3d 00 0c stw r9,12(r29)
ffc124c0: 4b ff ff b4 b ffc12474 <_RBTree_Extract_unprotected+0x114>
the_rbtree->first[RBT_LEFT] = NULL;
}
}
/* check if max needs to be updated: note, min can equal max (1 element) */
if (the_node == the_rbtree->first[RBT_RIGHT]) {
if (the_node->child[RBT_LEFT])
ffc124c4: 80 1e 00 04 lwz r0,4(r30)
ffc124c8: 2f 80 00 00 cmpwi cr7,r0,0
ffc124cc: 41 9e 00 90 beq- cr7,ffc1255c <_RBTree_Extract_unprotected+0x1fc>
the_rbtree->first[RBT_RIGHT] = the_node->child[RBT_LEFT];
else {
the_rbtree->first[RBT_RIGHT] = the_node->parent;
if(_RBTree_Are_nodes_equal((RBTree_Node *)the_rbtree,
the_rbtree->first[RBT_RIGHT]))
the_rbtree->first[RBT_RIGHT] = NULL;
ffc124d0: 90 1c 00 0c stw r0,12(r28)
* either max in node->child[RBT_LEFT] or min in node->child[RBT_RIGHT],
* and replace the_node with the target node. This maintains the binary
* search tree property, but may violate the red-black properties.
*/
if (the_node->child[RBT_LEFT] && the_node->child[RBT_RIGHT]) {
ffc124d4: 83 fe 00 04 lwz r31,4(r30)
ffc124d8: 2f 9f 00 00 cmpwi cr7,r31,0
ffc124dc: 40 9e fe d0 bne+ cr7,ffc123ac <_RBTree_Extract_unprotected+0x4c>
* the_node's location in the tree. This may cause the coloring to be
* violated. We will fix it later.
* For now we store the color of the node being deleted in victim_color.
*/
leaf = the_node->child[RBT_LEFT] ?
the_node->child[RBT_LEFT] : the_node->child[RBT_RIGHT];
ffc124e0: 83 be 00 08 lwz r29,8(r30)
if( leaf ) {
ffc124e4: 2f 9d 00 00 cmpwi cr7,r29,0
ffc124e8: 40 be 00 28 bne+ cr7,ffc12510 <_RBTree_Extract_unprotected+0x1b0>
leaf->parent = the_node->parent;
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(the_node);
ffc124ec: 7f c3 f3 78 mr r3,r30
ffc124f0: 4b ff fb 75 bl ffc12064 <_RBTree_Extract_validate_unprotected>
ffc124f4: 48 00 00 24 b ffc12518 <_RBTree_Extract_unprotected+0x1b8>
if (!the_node) return;
/* check if min needs to be updated */
if (the_node == the_rbtree->first[RBT_LEFT]) {
if (the_node->child[RBT_RIGHT])
ffc124f8: 80 1e 00 08 lwz r0,8(r30)
ffc124fc: 2f 80 00 00 cmpwi cr7,r0,0
ffc12500: 41 9e 00 44 beq- cr7,ffc12544 <_RBTree_Extract_unprotected+0x1e4>
the_rbtree->first[RBT_LEFT] = the_node->child[RBT_RIGHT];
else {
the_rbtree->first[RBT_LEFT] = the_node->parent;
if(_RBTree_Are_nodes_equal((RBTree_Node *)the_rbtree,
the_rbtree->first[RBT_LEFT]))
the_rbtree->first[RBT_LEFT] = NULL;
ffc12504: 90 1c 00 08 stw r0,8(r28)
ffc12508: 4b ff fe 8c b ffc12394 <_RBTree_Extract_unprotected+0x34>
* either max in node->child[RBT_LEFT] or min in node->child[RBT_RIGHT],
* and replace the_node with the target node. This maintains the binary
* search tree property, but may violate the red-black properties.
*/
if (the_node->child[RBT_LEFT] && the_node->child[RBT_RIGHT]) {
ffc1250c: 7f fd fb 78 mr r29,r31
* For now we store the color of the node being deleted in victim_color.
*/
leaf = the_node->child[RBT_LEFT] ?
the_node->child[RBT_LEFT] : the_node->child[RBT_RIGHT];
if( leaf ) {
leaf->parent = the_node->parent;
ffc12510: 80 1e 00 00 lwz r0,0(r30)
ffc12514: 90 1d 00 00 stw r0,0(r29)
_RBTree_Extract_validate_unprotected(the_node);
}
victim_color = the_node->color;
/* remove the_node from the tree */
dir = the_node != the_node->parent->child[0];
ffc12518: 81 7e 00 00 lwz r11,0(r30)
leaf->parent = the_node->parent;
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(the_node);
}
victim_color = the_node->color;
ffc1251c: 81 3e 00 0c lwz r9,12(r30)
/* remove the_node from the tree */
dir = the_node != the_node->parent->child[0];
ffc12520: 80 0b 00 04 lwz r0,4(r11)
ffc12524: 7f c0 02 78 xor r0,r30,r0
ffc12528: 7c 00 00 34 cntlzw r0,r0
ffc1252c: 54 00 d9 7e rlwinm r0,r0,27,5,31
ffc12530: 68 00 00 01 xori r0,r0,1
the_node->parent->child[dir] = leaf;
ffc12534: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc12538: 7d 6b 02 14 add r11,r11,r0
ffc1253c: 93 ab 00 04 stw r29,4(r11)
ffc12540: 4b ff ff 2c b ffc1246c <_RBTree_Extract_unprotected+0x10c>
/* check if min needs to be updated */
if (the_node == the_rbtree->first[RBT_LEFT]) {
if (the_node->child[RBT_RIGHT])
the_rbtree->first[RBT_LEFT] = the_node->child[RBT_RIGHT];
else {
the_rbtree->first[RBT_LEFT] = the_node->parent;
ffc12544: 81 3e 00 00 lwz r9,0(r30)
if(_RBTree_Are_nodes_equal((RBTree_Node *)the_rbtree,
ffc12548: 7f 83 48 00 cmpw cr7,r3,r9
/* check if min needs to be updated */
if (the_node == the_rbtree->first[RBT_LEFT]) {
if (the_node->child[RBT_RIGHT])
the_rbtree->first[RBT_LEFT] = the_node->child[RBT_RIGHT];
else {
the_rbtree->first[RBT_LEFT] = the_node->parent;
ffc1254c: 91 23 00 08 stw r9,8(r3)
if(_RBTree_Are_nodes_equal((RBTree_Node *)the_rbtree,
ffc12550: 40 9e fe 44 bne+ cr7,ffc12394 <_RBTree_Extract_unprotected+0x34>
the_rbtree->first[RBT_LEFT]))
the_rbtree->first[RBT_LEFT] = NULL;
ffc12554: 90 1c 00 08 stw r0,8(r28)
ffc12558: 4b ff fe 3c b ffc12394 <_RBTree_Extract_unprotected+0x34>
/* check if max needs to be updated: note, min can equal max (1 element) */
if (the_node == the_rbtree->first[RBT_RIGHT]) {
if (the_node->child[RBT_LEFT])
the_rbtree->first[RBT_RIGHT] = the_node->child[RBT_LEFT];
else {
the_rbtree->first[RBT_RIGHT] = the_node->parent;
ffc1255c: 81 3e 00 00 lwz r9,0(r30)
if(_RBTree_Are_nodes_equal((RBTree_Node *)the_rbtree,
ffc12560: 7f 9c 48 00 cmpw cr7,r28,r9
/* check if max needs to be updated: note, min can equal max (1 element) */
if (the_node == the_rbtree->first[RBT_RIGHT]) {
if (the_node->child[RBT_LEFT])
the_rbtree->first[RBT_RIGHT] = the_node->child[RBT_LEFT];
else {
the_rbtree->first[RBT_RIGHT] = the_node->parent;
ffc12564: 91 3c 00 0c stw r9,12(r28)
if(_RBTree_Are_nodes_equal((RBTree_Node *)the_rbtree,
ffc12568: 40 9e fe 38 bne+ cr7,ffc123a0 <_RBTree_Extract_unprotected+0x40>
the_rbtree->first[RBT_RIGHT]))
the_rbtree->first[RBT_RIGHT] = NULL;
ffc1256c: 90 1c 00 0c stw r0,12(r28)
ffc12570: 4b ff ff 64 b ffc124d4 <_RBTree_Extract_unprotected+0x174>
leaf = target->child[RBT_LEFT];
if(leaf) {
leaf->parent = target->parent;
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
ffc12574: 7f e3 fb 78 mr r3,r31
ffc12578: 4b ff fa ed bl ffc12064 <_RBTree_Extract_validate_unprotected>
ffc1257c: 4b ff fe 64 b ffc123e0 <_RBTree_Extract_unprotected+0x80>
ffc12064 <_RBTree_Extract_validate_unprotected>:
)
{
RBTree_Node *parent, *sibling;
RBTree_Direction dir;
parent = the_node->parent;
ffc12064: 81 23 00 00 lwz r9,0(r3)
if(!parent->parent) return;
ffc12068: 80 09 00 00 lwz r0,0(r9)
ffc1206c: 2f 80 00 00 cmpwi cr7,r0,0
ffc12070: 4d 9e 00 20 beqlr cr7
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(the_node == the_node->parent->child[RBT_LEFT])
ffc12074: 81 69 00 04 lwz r11,4(r9)
ffc12078: 7f 83 58 00 cmpw cr7,r3,r11
ffc1207c: 41 9e 02 dc beq- cr7,ffc12358 <_RBTree_Extract_validate_unprotected+0x2f4>
* Now the_node has a black sibling and red parent. After rotation,
* update sibling pointer.
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
sibling->color = RBT_BLACK;
ffc12080: 38 80 00 00 li r4,0
}
/* sibling is black, see if both of its children are also black. */
if (!_RBTree_Is_red(sibling->child[RBT_RIGHT]) &&
!_RBTree_Is_red(sibling->child[RBT_LEFT])) {
sibling->color = RBT_RED;
ffc12084: 38 e0 00 01 li r7,1
ffc12088: 48 00 00 94 b ffc1211c <_RBTree_Extract_validate_unprotected+0xb8>
if(!parent->parent) return;
sibling = _RBTree_Sibling(the_node);
/* continue to correct tree as long as the_node is black and not the root */
while (!_RBTree_Is_red(the_node) && parent->parent) {
ffc1208c: 81 49 00 00 lwz r10,0(r9)
ffc12090: 2f 8a 00 00 cmpwi cr7,r10,0
ffc12094: 41 9e 00 94 beq- cr7,ffc12128 <_RBTree_Extract_validate_unprotected+0xc4>
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
ffc12098: 2f 8b 00 00 cmpwi cr7,r11,0
ffc1209c: 41 9e 00 10 beq- cr7,ffc120ac <_RBTree_Extract_validate_unprotected+0x48><== NEVER TAKEN
ffc120a0: 80 0b 00 0c lwz r0,12(r11)
ffc120a4: 2f 80 00 01 cmpwi cr7,r0,1
ffc120a8: 41 9e 00 98 beq- cr7,ffc12140 <_RBTree_Extract_validate_unprotected+0xdc>
_RBTree_Rotate(parent, dir);
sibling = parent->child[!dir];
}
/* sibling is black, see if both of its children are also black. */
if (!_RBTree_Is_red(sibling->child[RBT_RIGHT]) &&
ffc120ac: 81 4b 00 08 lwz r10,8(r11)
ffc120b0: 2f 8a 00 00 cmpwi cr7,r10,0
ffc120b4: 41 9e 00 10 beq- cr7,ffc120c4 <_RBTree_Extract_validate_unprotected+0x60>
ffc120b8: 80 0a 00 0c lwz r0,12(r10)
ffc120bc: 2f 80 00 01 cmpwi cr7,r0,1
ffc120c0: 41 9e 01 40 beq- cr7,ffc12200 <_RBTree_Extract_validate_unprotected+0x19c>
!_RBTree_Is_red(sibling->child[RBT_LEFT])) {
ffc120c4: 81 4b 00 04 lwz r10,4(r11)
ffc120c8: 2f 8a 00 00 cmpwi cr7,r10,0
ffc120cc: 41 9e 00 10 beq- cr7,ffc120dc <_RBTree_Extract_validate_unprotected+0x78>
ffc120d0: 80 0a 00 0c lwz r0,12(r10)
ffc120d4: 2f 80 00 01 cmpwi cr7,r0,1
ffc120d8: 41 9e 01 28 beq- cr7,ffc12200 <_RBTree_Extract_validate_unprotected+0x19c>
sibling->color = RBT_RED;
ffc120dc: 90 eb 00 0c stw r7,12(r11)
ffc120e0: 80 09 00 0c lwz r0,12(r9)
ffc120e4: 2f 80 00 01 cmpwi cr7,r0,1
ffc120e8: 41 9e 00 f4 beq- cr7,ffc121dc <_RBTree_Extract_validate_unprotected+0x178>
if (_RBTree_Is_red(parent)) {
parent->color = RBT_BLACK;
break;
}
the_node = parent; /* done if parent is red */
parent = the_node->parent;
ffc120ec: 81 49 00 00 lwz r10,0(r9)
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
RBTree_Node *the_node
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
ffc120f0: 39 60 00 00 li r11,0
ffc120f4: 2f 8a 00 00 cmpwi cr7,r10,0
ffc120f8: 41 9e 00 1c beq- cr7,ffc12114 <_RBTree_Extract_validate_unprotected+0xb0><== NEVER TAKEN
if(!(the_node->parent->parent)) return NULL;
ffc120fc: 80 0a 00 00 lwz r0,0(r10)
ffc12100: 2f 80 00 00 cmpwi cr7,r0,0
ffc12104: 41 9e 00 10 beq- cr7,ffc12114 <_RBTree_Extract_validate_unprotected+0xb0>
if(the_node == the_node->parent->child[RBT_LEFT])
ffc12108: 81 6a 00 04 lwz r11,4(r10)
ffc1210c: 7f 89 58 00 cmpw cr7,r9,r11
ffc12110: 41 9e 00 e8 beq- cr7,ffc121f8 <_RBTree_Extract_validate_unprotected+0x194>
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
c->parent = the_node->parent;
the_node->parent = c;
ffc12114: 7d 23 4b 78 mr r3,r9
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
RBTree_Node *the_node
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
ffc12118: 7d 49 53 78 mr r9,r10
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
ffc1211c: 80 03 00 0c lwz r0,12(r3)
ffc12120: 2f 80 00 01 cmpwi cr7,r0,1
ffc12124: 40 9e ff 68 bne+ cr7,ffc1208c <_RBTree_Extract_validate_unprotected+0x28>
sibling->child[!dir]->color = RBT_BLACK;
_RBTree_Rotate(parent, dir);
break; /* done */
}
} /* while */
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
ffc12128: 81 23 00 00 lwz r9,0(r3)
ffc1212c: 80 09 00 00 lwz r0,0(r9)
ffc12130: 2f 80 00 00 cmpwi cr7,r0,0
ffc12134: 4c be 00 20 bnelr+ cr7
ffc12138: 90 03 00 0c stw r0,12(r3)
ffc1213c: 4e 80 00 20 blr
* update sibling pointer.
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
sibling->color = RBT_BLACK;
dir = the_node != parent->child[0];
ffc12140: 81 09 00 04 lwz r8,4(r9)
* then rotate parent left, making the sibling be the_node's grandparent.
* Now the_node has a black sibling and red parent. After rotation,
* update sibling pointer.
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
ffc12144: 90 09 00 0c stw r0,12(r9)
sibling->color = RBT_BLACK;
dir = the_node != parent->child[0];
ffc12148: 7c 60 42 78 xor r0,r3,r8
ffc1214c: 7c 00 00 34 cntlzw r0,r0
* Now the_node has a black sibling and red parent. After rotation,
* update sibling pointer.
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
sibling->color = RBT_BLACK;
ffc12150: 90 8b 00 0c stw r4,12(r11)
dir = the_node != parent->child[0];
ffc12154: 54 00 d9 7e rlwinm r0,r0,27,5,31
ffc12158: 68 00 00 01 xori r0,r0,1
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[(1-dir)] == NULL) return;
ffc1215c: 20 c0 00 01 subfic r6,r0,1
ffc12160: 54 c6 10 3a rlwinm r6,r6,2,0,29
ffc12164: 7c c9 32 14 add r6,r9,r6
ffc12168: 81 06 00 04 lwz r8,4(r6)
ffc1216c: 2f 88 00 00 cmpwi cr7,r8,0
ffc12170: 41 9e 00 58 beq- cr7,ffc121c8 <_RBTree_Extract_validate_unprotected+0x164><== NEVER TAKEN
c = the_node->child[(1-dir)];
the_node->child[(1-dir)] = c->child[dir];
ffc12174: 54 0b 10 3a rlwinm r11,r0,2,0,29
ffc12178: 7c a8 5a 14 add r5,r8,r11
ffc1217c: 81 85 00 04 lwz r12,4(r5)
ffc12180: 91 86 00 04 stw r12,4(r6)
if (c->child[dir])
ffc12184: 80 c5 00 04 lwz r6,4(r5)
ffc12188: 2f 86 00 00 cmpwi cr7,r6,0
ffc1218c: 41 9e 00 0c beq- cr7,ffc12198 <_RBTree_Extract_validate_unprotected+0x134><== NEVER TAKEN
c->child[dir]->parent = the_node;
ffc12190: 91 26 00 00 stw r9,0(r6)
ffc12194: 81 49 00 00 lwz r10,0(r9)
c->child[dir] = the_node;
ffc12198: 7d 68 5a 14 add r11,r8,r11
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
c->parent = the_node->parent;
ffc1219c: 91 48 00 00 stw r10,0(r8)
the_node->child[(1-dir)] = c->child[dir];
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
ffc121a0: 91 2b 00 04 stw r9,4(r11)
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
ffc121a4: 81 6a 00 04 lwz r11,4(r10)
c->parent = the_node->parent;
the_node->parent = c;
ffc121a8: 91 09 00 00 stw r8,0(r9)
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
ffc121ac: 7d 2b 5a 78 xor r11,r9,r11
ffc121b0: 7d 6b 00 34 cntlzw r11,r11
ffc121b4: 55 6b d9 7e rlwinm r11,r11,27,5,31
ffc121b8: 69 6b 00 01 xori r11,r11,1
ffc121bc: 55 6b 10 3a rlwinm r11,r11,2,0,29
ffc121c0: 7d 4a 5a 14 add r10,r10,r11
ffc121c4: 91 0a 00 04 stw r8,4(r10)
_RBTree_Rotate(parent, dir);
sibling = parent->child[!dir];
ffc121c8: 68 00 00 01 xori r0,r0,1
ffc121cc: 54 0b 10 3a rlwinm r11,r0,2,0,29
ffc121d0: 7d 69 5a 14 add r11,r9,r11
ffc121d4: 81 6b 00 04 lwz r11,4(r11)
ffc121d8: 4b ff fe d4 b ffc120ac <_RBTree_Extract_validate_unprotected+0x48>
/* sibling is black, see if both of its children are also black. */
if (!_RBTree_Is_red(sibling->child[RBT_RIGHT]) &&
!_RBTree_Is_red(sibling->child[RBT_LEFT])) {
sibling->color = RBT_RED;
if (_RBTree_Is_red(parent)) {
parent->color = RBT_BLACK;
ffc121dc: 38 00 00 00 li r0,0
ffc121e0: 90 09 00 0c stw r0,12(r9)
sibling->child[!dir]->color = RBT_BLACK;
_RBTree_Rotate(parent, dir);
break; /* done */
}
} /* while */
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
ffc121e4: 81 23 00 00 lwz r9,0(r3)
ffc121e8: 80 09 00 00 lwz r0,0(r9)
ffc121ec: 2f 80 00 00 cmpwi cr7,r0,0
ffc121f0: 4c be 00 20 bnelr+ cr7
ffc121f4: 4b ff ff 44 b ffc12138 <_RBTree_Extract_validate_unprotected+0xd4><== NOT EXECUTED
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(the_node == the_node->parent->child[RBT_LEFT])
return the_node->parent->child[RBT_RIGHT];
ffc121f8: 81 6a 00 08 lwz r11,8(r10)
ffc121fc: 4b ff ff 18 b ffc12114 <_RBTree_Extract_validate_unprotected+0xb0>
* cases, either the_node is to the left or the right of the parent.
* In both cases, first check if one of sibling's children is black,
* and if so rotate in the proper direction and update sibling pointer.
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
ffc12200: 80 09 00 04 lwz r0,4(r9)
ffc12204: 7c 60 02 78 xor r0,r3,r0
ffc12208: 7c 00 00 34 cntlzw r0,r0
ffc1220c: 54 00 d9 7e rlwinm r0,r0,27,5,31
ffc12210: 68 00 00 01 xori r0,r0,1
if (!_RBTree_Is_red(sibling->child[!dir])) {
ffc12214: 68 0a 00 01 xori r10,r0,1
ffc12218: 55 4a 10 3a rlwinm r10,r10,2,0,29
ffc1221c: 7d 0b 52 14 add r8,r11,r10
ffc12220: 81 08 00 04 lwz r8,4(r8)
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
ffc12224: 2f 88 00 00 cmpwi cr7,r8,0
ffc12228: 41 9e 00 10 beq- cr7,ffc12238 <_RBTree_Extract_validate_unprotected+0x1d4>
ffc1222c: 80 e8 00 0c lwz r7,12(r8)
ffc12230: 2f 87 00 01 cmpwi cr7,r7,1
ffc12234: 41 9e 00 a0 beq- cr7,ffc122d4 <_RBTree_Extract_validate_unprotected+0x270>
sibling->color = RBT_RED;
sibling->child[dir]->color = RBT_BLACK;
_RBTree_Rotate(sibling, !dir);
ffc12238: 68 06 00 01 xori r6,r0,1
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[(1-dir)] == NULL) return;
ffc1223c: 20 e6 00 01 subfic r7,r6,1
ffc12240: 54 e7 10 3a rlwinm r7,r7,2,0,29
ffc12244: 7c eb 3a 14 add r7,r11,r7
ffc12248: 81 07 00 04 lwz r8,4(r7)
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
if (!_RBTree_Is_red(sibling->child[!dir])) {
sibling->color = RBT_RED;
sibling->child[dir]->color = RBT_BLACK;
ffc1224c: 54 05 10 3a rlwinm r5,r0,2,0,29
ffc12250: 7c ab 2a 14 add r5,r11,r5
ffc12254: 2f 88 00 00 cmpwi cr7,r8,0
ffc12258: 80 a5 00 04 lwz r5,4(r5)
* and if so rotate in the proper direction and update sibling pointer.
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
if (!_RBTree_Is_red(sibling->child[!dir])) {
sibling->color = RBT_RED;
ffc1225c: 38 80 00 01 li r4,1
ffc12260: 90 8b 00 0c stw r4,12(r11)
sibling->child[dir]->color = RBT_BLACK;
ffc12264: 38 80 00 00 li r4,0
ffc12268: 90 85 00 0c stw r4,12(r5)
ffc1226c: 41 9e 00 58 beq- cr7,ffc122c4 <_RBTree_Extract_validate_unprotected+0x260><== NEVER TAKEN
c = the_node->child[(1-dir)];
the_node->child[(1-dir)] = c->child[dir];
ffc12270: 54 c6 10 3a rlwinm r6,r6,2,0,29
ffc12274: 7c a8 32 14 add r5,r8,r6
ffc12278: 80 85 00 04 lwz r4,4(r5)
ffc1227c: 90 87 00 04 stw r4,4(r7)
if (c->child[dir])
ffc12280: 80 e5 00 04 lwz r7,4(r5)
ffc12284: 2f 87 00 00 cmpwi cr7,r7,0
ffc12288: 41 9e 00 08 beq- cr7,ffc12290 <_RBTree_Extract_validate_unprotected+0x22c>
c->child[dir]->parent = the_node;
ffc1228c: 91 67 00 00 stw r11,0(r7)
c->child[dir] = the_node;
ffc12290: 7c e8 32 14 add r7,r8,r6
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
ffc12294: 80 cb 00 00 lwz r6,0(r11)
the_node->child[(1-dir)] = c->child[dir];
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
ffc12298: 91 67 00 04 stw r11,4(r7)
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
ffc1229c: 80 e6 00 04 lwz r7,4(r6)
c->parent = the_node->parent;
ffc122a0: 90 c8 00 00 stw r6,0(r8)
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
ffc122a4: 7d 67 3a 78 xor r7,r11,r7
ffc122a8: 7c e7 00 34 cntlzw r7,r7
c->parent = the_node->parent;
the_node->parent = c;
ffc122ac: 91 0b 00 00 stw r8,0(r11)
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
ffc122b0: 54 e7 d9 7e rlwinm r7,r7,27,5,31
ffc122b4: 68 e7 00 01 xori r7,r7,1
ffc122b8: 54 e7 10 3a rlwinm r7,r7,2,0,29
ffc122bc: 7c c6 3a 14 add r6,r6,r7
ffc122c0: 91 06 00 04 stw r8,4(r6)
_RBTree_Rotate(sibling, !dir);
sibling = parent->child[!dir];
ffc122c4: 7d 69 52 14 add r11,r9,r10
ffc122c8: 81 6b 00 04 lwz r11,4(r11)
ffc122cc: 7d 4b 52 14 add r10,r11,r10
ffc122d0: 81 0a 00 04 lwz r8,4(r10)
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[(1-dir)] == NULL) return;
ffc122d4: 20 c0 00 01 subfic r6,r0,1
}
sibling->color = parent->color;
ffc122d8: 80 a9 00 0c lwz r5,12(r9)
ffc122dc: 54 c6 10 3a rlwinm r6,r6,2,0,29
ffc122e0: 7c c9 32 14 add r6,r9,r6
ffc122e4: 90 ab 00 0c stw r5,12(r11)
parent->color = RBT_BLACK;
ffc122e8: 38 e0 00 00 li r7,0
ffc122ec: 81 46 00 04 lwz r10,4(r6)
ffc122f0: 90 e9 00 0c stw r7,12(r9)
ffc122f4: 2f 8a 00 00 cmpwi cr7,r10,0
sibling->child[!dir]->color = RBT_BLACK;
ffc122f8: 90 e8 00 0c stw r7,12(r8)
ffc122fc: 41 be fe 2c beq- cr7,ffc12128 <_RBTree_Extract_validate_unprotected+0xc4><== NEVER TAKEN
c = the_node->child[(1-dir)];
the_node->child[(1-dir)] = c->child[dir];
ffc12300: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc12304: 7d 6a 02 14 add r11,r10,r0
ffc12308: 81 0b 00 04 lwz r8,4(r11)
ffc1230c: 91 06 00 04 stw r8,4(r6)
if (c->child[dir])
ffc12310: 81 6b 00 04 lwz r11,4(r11)
ffc12314: 2f 8b 00 00 cmpwi cr7,r11,0
ffc12318: 41 9e 00 08 beq- cr7,ffc12320 <_RBTree_Extract_validate_unprotected+0x2bc>
c->child[dir]->parent = the_node;
ffc1231c: 91 2b 00 00 stw r9,0(r11)
c->child[dir] = the_node;
ffc12320: 7d 0a 02 14 add r8,r10,r0
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
ffc12324: 81 69 00 00 lwz r11,0(r9)
the_node->child[(1-dir)] = c->child[dir];
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
ffc12328: 91 28 00 04 stw r9,4(r8)
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
ffc1232c: 80 0b 00 04 lwz r0,4(r11)
c->parent = the_node->parent;
ffc12330: 91 6a 00 00 stw r11,0(r10)
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
ffc12334: 7d 20 02 78 xor r0,r9,r0
ffc12338: 7c 00 00 34 cntlzw r0,r0
c->parent = the_node->parent;
the_node->parent = c;
ffc1233c: 91 49 00 00 stw r10,0(r9)
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
ffc12340: 54 00 d9 7e rlwinm r0,r0,27,5,31
ffc12344: 68 00 00 01 xori r0,r0,1
ffc12348: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc1234c: 7d 6b 02 14 add r11,r11,r0
ffc12350: 91 4b 00 04 stw r10,4(r11)
ffc12354: 4b ff fd d4 b ffc12128 <_RBTree_Extract_validate_unprotected+0xc4>
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(the_node == the_node->parent->child[RBT_LEFT])
return the_node->parent->child[RBT_RIGHT];
ffc12358: 81 69 00 08 lwz r11,8(r9)
ffc1235c: 4b ff fd 24 b ffc12080 <_RBTree_Extract_validate_unprotected+0x1c>
ffc0c818 <_RBTree_Find>:
RBTree_Node *_RBTree_Find(
RBTree_Control *the_rbtree,
RBTree_Node *search_node
)
{
ffc0c818: 94 21 ff e0 stwu r1,-32(r1)
ffc0c81c: 7c 08 02 a6 mflr r0
ffc0c820: 90 01 00 24 stw r0,36(r1)
ffc0c824: 93 a1 00 14 stw r29,20(r1)
ffc0c828: 7c 9d 23 78 mr r29,r4
ffc0c82c: 93 c1 00 18 stw r30,24(r1)
ffc0c830: 7c 7e 1b 78 mr r30,r3
ffc0c834: 93 61 00 0c stw r27,12(r1)
ffc0c838: 93 81 00 10 stw r28,16(r1)
ffc0c83c: 93 e1 00 1c stw r31,28(r1)
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0c840: 7f 60 00 a6 mfmsr r27
ffc0c844: 7c 10 42 a6 mfsprg r0,0
ffc0c848: 7f 60 00 78 andc r0,r27,r0
ffc0c84c: 7c 00 01 24 mtmsr r0
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Find_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
RBTree_Node* iter_node = the_rbtree->root;
ffc0c850: 83 e3 00 04 lwz r31,4(r3)
RBTree_Node* found = NULL;
ffc0c854: 3b 80 00 00 li r28,0
int compare_result;
while (iter_node) {
ffc0c858: 2f 9f 00 00 cmpwi cr7,r31,0
ffc0c85c: 41 9e 00 50 beq- cr7,ffc0c8ac <_RBTree_Find+0x94> <== NEVER TAKEN
compare_result = the_rbtree->compare_function(the_node, iter_node);
ffc0c860: 80 1e 00 10 lwz r0,16(r30)
ffc0c864: 7f e4 fb 78 mr r4,r31
ffc0c868: 7f a3 eb 78 mr r3,r29
ffc0c86c: 7c 09 03 a6 mtctr r0
ffc0c870: 4e 80 04 21 bctrl
if (compare_result == 0) {
ffc0c874: 2c 03 00 00 cmpwi r3,0
found = iter_node;
if ( the_rbtree->is_unique )
break;
}
RBTree_Direction dir = (compare_result == 1);
ffc0c878: 68 63 00 01 xori r3,r3,1
ffc0c87c: 7c 63 00 34 cntlzw r3,r3
ffc0c880: 54 63 d9 7e rlwinm r3,r3,27,5,31
iter_node = iter_node->child[dir];
ffc0c884: 54 63 10 3a rlwinm r3,r3,2,0,29
ffc0c888: 7c 7f 1a 14 add r3,r31,r3
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
if (compare_result == 0) {
ffc0c88c: 40 82 00 14 bne- ffc0c8a0 <_RBTree_Find+0x88>
found = iter_node;
if ( the_rbtree->is_unique )
ffc0c890: 88 1e 00 14 lbz r0,20(r30)
ffc0c894: 7f fc fb 78 mr r28,r31
ffc0c898: 2f 80 00 00 cmpwi cr7,r0,0
ffc0c89c: 40 9e 00 3c bne- cr7,ffc0c8d8 <_RBTree_Find+0xc0>
break;
}
RBTree_Direction dir = (compare_result == 1);
iter_node = iter_node->child[dir];
ffc0c8a0: 83 e3 00 04 lwz r31,4(r3)
)
{
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
ffc0c8a4: 2f 9f 00 00 cmpwi cr7,r31,0
ffc0c8a8: 40 9e ff b8 bne+ cr7,ffc0c860 <_RBTree_Find+0x48>
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0c8ac: 7f 60 01 24 mtmsr r27
return_node = NULL;
_ISR_Disable( level );
return_node = _RBTree_Find_unprotected( the_rbtree, search_node );
_ISR_Enable( level );
return return_node;
}
ffc0c8b0: 80 01 00 24 lwz r0,36(r1)
ffc0c8b4: 7f 83 e3 78 mr r3,r28
ffc0c8b8: 83 61 00 0c lwz r27,12(r1)
ffc0c8bc: 7c 08 03 a6 mtlr r0
ffc0c8c0: 83 81 00 10 lwz r28,16(r1)
ffc0c8c4: 83 a1 00 14 lwz r29,20(r1)
ffc0c8c8: 83 c1 00 18 lwz r30,24(r1)
ffc0c8cc: 83 e1 00 1c lwz r31,28(r1)
ffc0c8d0: 38 21 00 20 addi r1,r1,32
ffc0c8d4: 4e 80 00 20 blr
compare_result = the_rbtree->compare_function(the_node, iter_node);
if (compare_result == 0) {
found = iter_node;
if ( the_rbtree->is_unique )
ffc0c8d8: 7f fc fb 78 mr r28,r31
ffc0c8dc: 7f 60 01 24 mtmsr r27
ffc0c8e0: 80 01 00 24 lwz r0,36(r1)
ffc0c8e4: 7f 83 e3 78 mr r3,r28
ffc0c8e8: 83 61 00 0c lwz r27,12(r1)
ffc0c8ec: 7c 08 03 a6 mtlr r0
ffc0c8f0: 83 81 00 10 lwz r28,16(r1)
ffc0c8f4: 83 a1 00 14 lwz r29,20(r1)
ffc0c8f8: 83 c1 00 18 lwz r30,24(r1)
ffc0c8fc: 83 e1 00 1c lwz r31,28(r1)
ffc0c900: 38 21 00 20 addi r1,r1,32
ffc0c904: 4e 80 00 20 blr
ffc0cc74 <_RBTree_Initialize>:
void *starting_address,
size_t number_nodes,
size_t node_size,
bool is_unique
)
{
ffc0cc74: 94 21 ff e0 stwu r1,-32(r1)
ffc0cc78: 7c 08 02 a6 mflr r0
ffc0cc7c: 93 e1 00 1c stw r31,28(r1)
size_t count;
RBTree_Node *next;
/* TODO: Error message? */
if (!the_rbtree) return;
ffc0cc80: 7c 7f 1b 79 mr. r31,r3
void *starting_address,
size_t number_nodes,
size_t node_size,
bool is_unique
)
{
ffc0cc84: 93 c1 00 18 stw r30,24(r1)
ffc0cc88: 7c fe 3b 78 mr r30,r7
ffc0cc8c: 90 01 00 24 stw r0,36(r1)
ffc0cc90: 93 a1 00 14 stw r29,20(r1)
ffc0cc94: 90 c1 00 08 stw r6,8(r1)
size_t count;
RBTree_Node *next;
/* TODO: Error message? */
if (!the_rbtree) return;
ffc0cc98: 41 82 00 4c beq- ffc0cce4 <_RBTree_Initialize+0x70> <== NEVER TAKEN
/* could do sanity checks here */
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
while ( count-- ) {
ffc0cc9c: 2f 86 00 00 cmpwi cr7,r6,0
{
the_rbtree->permanent_null = NULL;
the_rbtree->root = NULL;
the_rbtree->first[0] = NULL;
the_rbtree->first[1] = NULL;
the_rbtree->compare_function = compare_function;
ffc0cca0: 90 9f 00 10 stw r4,16(r31)
RBTree_Control *the_rbtree,
RBTree_Compare_function compare_function,
bool is_unique
)
{
the_rbtree->permanent_null = NULL;
ffc0cca4: 38 00 00 00 li r0,0
ffc0cca8: 90 1f 00 00 stw r0,0(r31)
the_rbtree->root = NULL;
ffc0ccac: 90 1f 00 04 stw r0,4(r31)
the_rbtree->first[0] = NULL;
ffc0ccb0: 90 1f 00 08 stw r0,8(r31)
the_rbtree->first[1] = NULL;
ffc0ccb4: 90 1f 00 0c stw r0,12(r31)
the_rbtree->compare_function = compare_function;
the_rbtree->is_unique = is_unique;
ffc0ccb8: 99 1f 00 14 stb r8,20(r31)
ffc0ccbc: 41 9e 00 28 beq- cr7,ffc0cce4 <_RBTree_Initialize+0x70> <== NEVER TAKEN
/* could do sanity checks here */
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
ffc0ccc0: 7c bd 2b 78 mr r29,r5
while ( count-- ) {
_RBTree_Insert(the_rbtree, next);
ffc0ccc4: 7f a4 eb 78 mr r4,r29
ffc0ccc8: 7f e3 fb 78 mr r3,r31
ffc0cccc: 4b ff ff 95 bl ffc0cc60 <_RBTree_Insert>
/* could do sanity checks here */
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
while ( count-- ) {
ffc0ccd0: 80 01 00 08 lwz r0,8(r1)
* node_size - size of node in bytes
*
* Output parameters: NONE
*/
void _RBTree_Initialize(
ffc0ccd4: 7f bd f2 14 add r29,r29,r30
/* could do sanity checks here */
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
while ( count-- ) {
ffc0ccd8: 35 20 ff ff addic. r9,r0,-1
ffc0ccdc: 91 21 00 08 stw r9,8(r1)
ffc0cce0: 40 82 ff e4 bne+ ffc0ccc4 <_RBTree_Initialize+0x50>
_RBTree_Insert(the_rbtree, next);
next = (RBTree_Node *)
_Addresses_Add_offset( (void *) next, node_size );
}
}
ffc0cce4: 80 01 00 24 lwz r0,36(r1)
ffc0cce8: 83 a1 00 14 lwz r29,20(r1)
ffc0ccec: 7c 08 03 a6 mtlr r0
ffc0ccf0: 83 c1 00 18 lwz r30,24(r1)
ffc0ccf4: 83 e1 00 1c lwz r31,28(r1)
ffc0ccf8: 38 21 00 20 addi r1,r1,32
ffc0ccfc: 4e 80 00 20 blr
ffc125bc <_RBTree_Validate_insert_unprotected>:
* append operation.
*/
void _RBTree_Validate_insert_unprotected(
RBTree_Node *the_node
)
{
ffc125bc: 94 21 ff f0 stwu r1,-16(r1)
/* ensure node is on the same branch direction as parent */
if (dir != pdir) {
_RBTree_Rotate(the_node->parent, pdir);
the_node = the_node->child[pdir];
}
the_node->parent->color = RBT_BLACK;
ffc125c0: 38 a0 00 00 li r5,0
g->color = RBT_RED;
ffc125c4: 39 80 00 01 li r12,1
* append operation.
*/
void _RBTree_Validate_insert_unprotected(
RBTree_Node *the_node
)
{
ffc125c8: 93 e1 00 0c stw r31,12(r1)
ISR_Level level;
_ISR_Disable( level );
return _RBTree_Insert_unprotected( tree, node );
_ISR_Enable( level );
}
ffc125cc: 81 23 00 00 lwz r9,0(r3)
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent(
RBTree_Node *the_node
)
{
if (!the_node->parent->parent) return NULL;
ffc125d0: 81 69 00 00 lwz r11,0(r9)
ffc125d4: 2f 8b 00 00 cmpwi cr7,r11,0
ffc125d8: 7d 68 5b 78 mr r8,r11
ffc125dc: 41 9e 01 70 beq- cr7,ffc1274c <_RBTree_Validate_insert_unprotected+0x190>
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
ffc125e0: 80 09 00 0c lwz r0,12(r9)
ffc125e4: 2f 80 00 01 cmpwi cr7,r0,1
ffc125e8: 41 9e 00 10 beq- cr7,ffc125f8 <_RBTree_Validate_insert_unprotected+0x3c>
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
}
}
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
}
ffc125ec: 83 e1 00 0c lwz r31,12(r1)
ffc125f0: 38 21 00 10 addi r1,r1,16
ffc125f4: 4e 80 00 20 blr
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(!(the_node->parent->parent->parent)) return NULL;
ffc125f8: 80 0b 00 00 lwz r0,0(r11)
ffc125fc: 2f 80 00 00 cmpwi cr7,r0,0
ffc12600: 80 0b 00 04 lwz r0,4(r11)
ffc12604: 41 9e 00 24 beq- cr7,ffc12628 <_RBTree_Validate_insert_unprotected+0x6c><== NEVER TAKEN
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(the_node == the_node->parent->child[RBT_LEFT])
ffc12608: 7f 89 00 00 cmpw cr7,r9,r0
ffc1260c: 7c 0a 03 78 mr r10,r0
ffc12610: 41 9e 01 6c beq- cr7,ffc1277c <_RBTree_Validate_insert_unprotected+0x1c0>
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
ffc12614: 2f 8a 00 00 cmpwi cr7,r10,0
ffc12618: 41 9e 00 10 beq- cr7,ffc12628 <_RBTree_Validate_insert_unprotected+0x6c>
ffc1261c: 80 ea 00 0c lwz r7,12(r10)
ffc12620: 2f 87 00 01 cmpwi cr7,r7,1
ffc12624: 41 9e 01 38 beq- cr7,ffc1275c <_RBTree_Validate_insert_unprotected+0x1a0>
the_node->parent->color = RBT_BLACK;
u->color = RBT_BLACK;
g->color = RBT_RED;
the_node = g;
} else { /* if uncle is black */
RBTree_Direction dir = the_node != the_node->parent->child[0];
ffc12628: 81 49 00 04 lwz r10,4(r9)
RBTree_Direction pdir = the_node->parent != g->child[0];
ffc1262c: 7d 20 02 78 xor r0,r9,r0
ffc12630: 7c 00 00 34 cntlzw r0,r0
the_node->parent->color = RBT_BLACK;
u->color = RBT_BLACK;
g->color = RBT_RED;
the_node = g;
} else { /* if uncle is black */
RBTree_Direction dir = the_node != the_node->parent->child[0];
ffc12634: 7c 6a 52 78 xor r10,r3,r10
ffc12638: 7d 4a 00 34 cntlzw r10,r10
ffc1263c: 55 4a d9 7e rlwinm r10,r10,27,5,31
RBTree_Direction pdir = the_node->parent != g->child[0];
ffc12640: 54 00 d9 7e rlwinm r0,r0,27,5,31
the_node->parent->color = RBT_BLACK;
u->color = RBT_BLACK;
g->color = RBT_RED;
the_node = g;
} else { /* if uncle is black */
RBTree_Direction dir = the_node != the_node->parent->child[0];
ffc12644: 69 4a 00 01 xori r10,r10,1
RBTree_Direction pdir = the_node->parent != g->child[0];
ffc12648: 68 00 00 01 xori r0,r0,1
/* ensure node is on the same branch direction as parent */
if (dir != pdir) {
ffc1264c: 7f 8a 00 00 cmpw cr7,r10,r0
ffc12650: 41 9e 01 20 beq- cr7,ffc12770 <_RBTree_Validate_insert_unprotected+0x1b4>
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[(1-dir)] == NULL) return;
ffc12654: 20 c0 00 01 subfic r6,r0,1
ffc12658: 54 ca 10 3a rlwinm r10,r6,2,0,29
ffc1265c: 7d 49 52 14 add r10,r9,r10
ffc12660: 80 ea 00 04 lwz r7,4(r10)
ffc12664: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc12668: 2f 87 00 00 cmpwi cr7,r7,0
ffc1266c: 41 9e 00 54 beq- cr7,ffc126c0 <_RBTree_Validate_insert_unprotected+0x104><== NEVER TAKEN
c = the_node->child[(1-dir)];
the_node->child[(1-dir)] = c->child[dir];
ffc12670: 7c 87 02 14 add r4,r7,r0
ffc12674: 83 e4 00 04 lwz r31,4(r4)
ffc12678: 93 ea 00 04 stw r31,4(r10)
if (c->child[dir])
ffc1267c: 81 44 00 04 lwz r10,4(r4)
ffc12680: 2f 8a 00 00 cmpwi cr7,r10,0
ffc12684: 41 9e 00 0c beq- cr7,ffc12690 <_RBTree_Validate_insert_unprotected+0xd4>
c->child[dir]->parent = the_node;
ffc12688: 91 2a 00 00 stw r9,0(r10)
ffc1268c: 81 69 00 00 lwz r11,0(r9)
c->child[dir] = the_node;
ffc12690: 7d 47 02 14 add r10,r7,r0
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
c->parent = the_node->parent;
ffc12694: 91 67 00 00 stw r11,0(r7)
the_node->child[(1-dir)] = c->child[dir];
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
ffc12698: 91 2a 00 04 stw r9,4(r10)
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
ffc1269c: 81 4b 00 04 lwz r10,4(r11)
c->parent = the_node->parent;
the_node->parent = c;
ffc126a0: 90 e9 00 00 stw r7,0(r9)
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
ffc126a4: 7d 2a 52 78 xor r10,r9,r10
ffc126a8: 7d 4a 00 34 cntlzw r10,r10
ffc126ac: 55 4a d9 7e rlwinm r10,r10,27,5,31
ffc126b0: 69 4a 00 01 xori r10,r10,1
ffc126b4: 55 4a 10 3a rlwinm r10,r10,2,0,29
ffc126b8: 7d 6b 52 14 add r11,r11,r10
ffc126bc: 90 eb 00 04 stw r7,4(r11)
_RBTree_Rotate(the_node->parent, pdir);
the_node = the_node->child[pdir];
ffc126c0: 7c 63 02 14 add r3,r3,r0
ffc126c4: 80 63 00 04 lwz r3,4(r3)
ffc126c8: 81 23 00 00 lwz r9,0(r3)
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[(1-dir)] == NULL) return;
ffc126cc: 7d 48 02 14 add r10,r8,r0
}
the_node->parent->color = RBT_BLACK;
ffc126d0: 90 a9 00 0c stw r5,12(r9)
ffc126d4: 81 6a 00 04 lwz r11,4(r10)
g->color = RBT_RED;
ffc126d8: 91 88 00 0c stw r12,12(r8)
ffc126dc: 2f 8b 00 00 cmpwi cr7,r11,0
ffc126e0: 41 be fe ec beq- cr7,ffc125cc <_RBTree_Validate_insert_unprotected+0x10><== NEVER TAKEN
c = the_node->child[(1-dir)];
the_node->child[(1-dir)] = c->child[dir];
ffc126e4: 54 c6 10 3a rlwinm r6,r6,2,0,29
ffc126e8: 7d 2b 32 14 add r9,r11,r6
ffc126ec: 80 09 00 04 lwz r0,4(r9)
ffc126f0: 90 0a 00 04 stw r0,4(r10)
if (c->child[dir])
ffc126f4: 81 29 00 04 lwz r9,4(r9)
ffc126f8: 2f 89 00 00 cmpwi cr7,r9,0
ffc126fc: 41 9e 00 08 beq- cr7,ffc12704 <_RBTree_Validate_insert_unprotected+0x148>
c->child[dir]->parent = the_node;
ffc12700: 91 09 00 00 stw r8,0(r9)
c->child[dir] = the_node;
ffc12704: 7c cb 32 14 add r6,r11,r6
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
ffc12708: 81 28 00 00 lwz r9,0(r8)
the_node->child[(1-dir)] = c->child[dir];
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
ffc1270c: 91 06 00 04 stw r8,4(r6)
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
ffc12710: 80 09 00 04 lwz r0,4(r9)
c->parent = the_node->parent;
ffc12714: 91 2b 00 00 stw r9,0(r11)
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
ffc12718: 7d 00 02 78 xor r0,r8,r0
ffc1271c: 7c 00 00 34 cntlzw r0,r0
c->parent = the_node->parent;
the_node->parent = c;
ffc12720: 91 68 00 00 stw r11,0(r8)
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
ffc12724: 54 00 d9 7e rlwinm r0,r0,27,5,31
ffc12728: 68 00 00 01 xori r0,r0,1
ffc1272c: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc12730: 7d 29 02 14 add r9,r9,r0
ffc12734: 91 69 00 04 stw r11,4(r9)
ISR_Level level;
_ISR_Disable( level );
return _RBTree_Insert_unprotected( tree, node );
_ISR_Enable( level );
}
ffc12738: 81 23 00 00 lwz r9,0(r3)
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent(
RBTree_Node *the_node
)
{
if (!the_node->parent->parent) return NULL;
ffc1273c: 81 69 00 00 lwz r11,0(r9)
ffc12740: 2f 8b 00 00 cmpwi cr7,r11,0
ffc12744: 7d 68 5b 78 mr r8,r11
ffc12748: 40 9e fe 98 bne+ cr7,ffc125e0 <_RBTree_Validate_insert_unprotected+0x24><== ALWAYS TAKEN
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
}
}
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
}
ffc1274c: 83 e1 00 0c lwz r31,12(r1)
ffc12750: 38 21 00 10 addi r1,r1,16
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
}
}
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
ffc12754: 91 63 00 0c stw r11,12(r3)
}
ffc12758: 4e 80 00 20 blr
u = _RBTree_Parent_sibling(the_node);
g = the_node->parent->parent;
/* if uncle is red, repaint uncle/parent black and grandparent red */
if(_RBTree_Is_red(u)) {
the_node->parent->color = RBT_BLACK;
ffc1275c: 90 a9 00 0c stw r5,12(r9)
u->color = RBT_BLACK;
g->color = RBT_RED;
ffc12760: 7d 63 5b 78 mr r3,r11
g = the_node->parent->parent;
/* if uncle is red, repaint uncle/parent black and grandparent red */
if(_RBTree_Is_red(u)) {
the_node->parent->color = RBT_BLACK;
u->color = RBT_BLACK;
ffc12764: 90 aa 00 0c stw r5,12(r10)
g->color = RBT_RED;
ffc12768: 90 eb 00 0c stw r7,12(r11)
ffc1276c: 4b ff fe 60 b ffc125cc <_RBTree_Validate_insert_unprotected+0x10>
} else { /* if uncle is black */
RBTree_Direction dir = the_node != the_node->parent->child[0];
RBTree_Direction pdir = the_node->parent != g->child[0];
/* ensure node is on the same branch direction as parent */
if (dir != pdir) {
ffc12770: 20 ca 00 01 subfic r6,r10,1
ffc12774: 55 40 10 3a rlwinm r0,r10,2,0,29
ffc12778: 4b ff ff 54 b ffc126cc <_RBTree_Validate_insert_unprotected+0x110>
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(the_node == the_node->parent->child[RBT_LEFT])
return the_node->parent->child[RBT_RIGHT];
ffc1277c: 81 4b 00 08 lwz r10,8(r11)
ffc12780: 4b ff fe 94 b ffc12614 <_RBTree_Validate_insert_unprotected+0x58>
ffc098e4 <_RTEMS_tasks_Initialize_user_tasks_body>:
*
* Output parameters: NONE
*/
void _RTEMS_tasks_Initialize_user_tasks_body( void )
{
ffc098e4: 94 21 ff d8 stwu r1,-40(r1)
ffc098e8: 7c 08 02 a6 mflr r0
rtems_initialization_tasks_table *user_tasks;
/*
* Move information into local variables
*/
user_tasks = Configuration_RTEMS_API.User_initialization_tasks_table;
ffc098ec: 3d 20 00 00 lis r9,0
*
* Output parameters: NONE
*/
void _RTEMS_tasks_Initialize_user_tasks_body( void )
{
ffc098f0: 90 01 00 2c stw r0,44(r1)
rtems_initialization_tasks_table *user_tasks;
/*
* Move information into local variables
*/
user_tasks = Configuration_RTEMS_API.User_initialization_tasks_table;
ffc098f4: 39 29 20 44 addi r9,r9,8260
*
* Output parameters: NONE
*/
void _RTEMS_tasks_Initialize_user_tasks_body( void )
{
ffc098f8: 93 e1 00 24 stw r31,36(r1)
rtems_initialization_tasks_table *user_tasks;
/*
* Move information into local variables
*/
user_tasks = Configuration_RTEMS_API.User_initialization_tasks_table;
ffc098fc: 83 e9 00 2c lwz r31,44(r9)
*
* Output parameters: NONE
*/
void _RTEMS_tasks_Initialize_user_tasks_body( void )
{
ffc09900: 93 a1 00 1c stw r29,28(r1)
maximum = Configuration_RTEMS_API.number_of_initialization_tasks;
/*
* Verify that we have a set of user tasks to iterate
*/
if ( !user_tasks )
ffc09904: 2f 9f 00 00 cmpwi cr7,r31,0
*
* Output parameters: NONE
*/
void _RTEMS_tasks_Initialize_user_tasks_body( void )
{
ffc09908: 93 c1 00 20 stw r30,32(r1)
/*
* Move information into local variables
*/
user_tasks = Configuration_RTEMS_API.User_initialization_tasks_table;
maximum = Configuration_RTEMS_API.number_of_initialization_tasks;
ffc0990c: 83 a9 00 28 lwz r29,40(r9)
/*
* Verify that we have a set of user tasks to iterate
*/
if ( !user_tasks )
ffc09910: 41 9e 00 5c beq- cr7,ffc0996c <_RTEMS_tasks_Initialize_user_tasks_body+0x88>
return;
/*
* Now iterate over the initialization tasks and create/start them.
*/
for ( index=0 ; index < maximum ; index++ ) {
ffc09914: 2f 9d 00 00 cmpwi cr7,r29,0
ffc09918: 41 9e 00 54 beq- cr7,ffc0996c <_RTEMS_tasks_Initialize_user_tasks_body+0x88><== NEVER TAKEN
ffc0991c: 3b c0 00 00 li r30,0
return_value = rtems_task_create(
ffc09920: 80 bf 00 04 lwz r5,4(r31)
ffc09924: 39 01 00 08 addi r8,r1,8
ffc09928: 80 7f 00 00 lwz r3,0(r31)
ffc0992c: 80 9f 00 08 lwz r4,8(r31)
ffc09930: 80 df 00 14 lwz r6,20(r31)
ffc09934: 80 ff 00 0c lwz r7,12(r31)
ffc09938: 4b ff fd 0d bl ffc09644 <rtems_task_create>
user_tasks[ index ].stack_size,
user_tasks[ index ].mode_set,
user_tasks[ index ].attribute_set,
&id
);
if ( !rtems_is_status_successful( return_value ) )
ffc0993c: 7c 65 1b 79 mr. r5,r3
ffc09940: 40 82 00 48 bne- ffc09988 <_RTEMS_tasks_Initialize_user_tasks_body+0xa4>
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
return_value = rtems_task_start(
ffc09944: 80 bf 00 18 lwz r5,24(r31)
ffc09948: 80 61 00 08 lwz r3,8(r1)
ffc0994c: 80 9f 00 10 lwz r4,16(r31)
ffc09950: 48 00 00 45 bl ffc09994 <rtems_task_start>
id,
user_tasks[ index ].entry_point,
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
ffc09954: 7c 65 1b 79 mr. r5,r3
ffc09958: 40 82 00 30 bne- ffc09988 <_RTEMS_tasks_Initialize_user_tasks_body+0xa4>
return;
/*
* Now iterate over the initialization tasks and create/start them.
*/
for ( index=0 ; index < maximum ; index++ ) {
ffc0995c: 3b de 00 01 addi r30,r30,1
ffc09960: 7f 9e e8 00 cmpw cr7,r30,r29
ffc09964: 3b ff 00 1c addi r31,r31,28
ffc09968: 40 9e ff b8 bne+ cr7,ffc09920 <_RTEMS_tasks_Initialize_user_tasks_body+0x3c><== NEVER TAKEN
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
}
}
ffc0996c: 80 01 00 2c lwz r0,44(r1)
ffc09970: 83 a1 00 1c lwz r29,28(r1)
ffc09974: 7c 08 03 a6 mtlr r0
ffc09978: 83 c1 00 20 lwz r30,32(r1)
ffc0997c: 83 e1 00 24 lwz r31,36(r1)
ffc09980: 38 21 00 28 addi r1,r1,40
ffc09984: 4e 80 00 20 blr
id,
user_tasks[ index ].entry_point,
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
ffc09988: 38 60 00 01 li r3,1
ffc0998c: 38 80 00 01 li r4,1
ffc09990: 48 00 14 31 bl ffc0adc0 <_Internal_error_Occurred>
ffc10958 <_RTEMS_tasks_Switch_extension>:
/*
* Per Task Variables
*/
tvp = executing->task_variables;
ffc10958: 81 23 01 3c lwz r9,316(r3)
while (tvp) {
ffc1095c: 2f 89 00 00 cmpwi cr7,r9,0
ffc10960: 41 9e 00 24 beq- cr7,ffc10984 <_RTEMS_tasks_Switch_extension+0x2c>
tvp->tval = *tvp->ptr;
ffc10964: 81 69 00 04 lwz r11,4(r9)
*tvp->ptr = tvp->gval;
ffc10968: 80 09 00 08 lwz r0,8(r9)
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
tvp->tval = *tvp->ptr;
ffc1096c: 81 4b 00 00 lwz r10,0(r11)
ffc10970: 91 49 00 0c stw r10,12(r9)
*tvp->ptr = tvp->gval;
ffc10974: 90 0b 00 00 stw r0,0(r11)
tvp = (rtems_task_variable_t *)tvp->next;
ffc10978: 81 29 00 00 lwz r9,0(r9)
/*
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
ffc1097c: 2f 89 00 00 cmpwi cr7,r9,0
ffc10980: 40 9e ff e4 bne+ cr7,ffc10964 <_RTEMS_tasks_Switch_extension+0xc><== NEVER TAKEN
tvp->tval = *tvp->ptr;
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
ffc10984: 81 24 01 3c lwz r9,316(r4)
while (tvp) {
ffc10988: 2f 89 00 00 cmpwi cr7,r9,0
ffc1098c: 4d 9e 00 20 beqlr cr7
tvp->gval = *tvp->ptr;
ffc10990: 81 69 00 04 lwz r11,4(r9)
*tvp->ptr = tvp->tval;
ffc10994: 80 09 00 0c lwz r0,12(r9)
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
while (tvp) {
tvp->gval = *tvp->ptr;
ffc10998: 81 4b 00 00 lwz r10,0(r11)
ffc1099c: 91 49 00 08 stw r10,8(r9)
*tvp->ptr = tvp->tval;
ffc109a0: 90 0b 00 00 stw r0,0(r11)
tvp = (rtems_task_variable_t *)tvp->next;
ffc109a4: 81 29 00 00 lwz r9,0(r9)
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
while (tvp) {
ffc109a8: 2f 89 00 00 cmpwi cr7,r9,0
ffc109ac: 40 9e ff e4 bne+ cr7,ffc10990 <_RTEMS_tasks_Switch_extension+0x38><== NEVER TAKEN
ffc109b0: 4e 80 00 20 blr
ffc0a8c8 <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
ffc0a8c8: 94 21 ff e0 stwu r1,-32(r1)
ffc0a8cc: 7c 08 02 a6 mflr r0
ffc0a8d0: 7c 64 1b 78 mr r4,r3
ffc0a8d4: 3c 60 00 00 lis r3,0
ffc0a8d8: 90 01 00 24 stw r0,36(r1)
ffc0a8dc: 38 63 2c 98 addi r3,r3,11416
ffc0a8e0: 38 a1 00 08 addi r5,r1,8
ffc0a8e4: 93 e1 00 1c stw r31,28(r1)
ffc0a8e8: 48 00 28 01 bl ffc0d0e8 <_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 ) {
ffc0a8ec: 80 01 00 08 lwz r0,8(r1)
ffc0a8f0: 7c 7f 1b 78 mr r31,r3
ffc0a8f4: 2f 80 00 00 cmpwi cr7,r0,0
ffc0a8f8: 40 9e 00 4c bne- cr7,ffc0a944 <_Rate_monotonic_Timeout+0x7c><== NEVER TAKEN
case OBJECTS_LOCAL:
the_thread = the_period->owner;
ffc0a8fc: 80 63 00 40 lwz r3,64(r3)
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_for_period (
States_Control the_states
)
{
return (the_states & STATES_WAITING_FOR_PERIOD);
ffc0a900: 80 03 00 10 lwz r0,16(r3)
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
ffc0a904: 70 09 40 00 andi. r9,r0,16384
ffc0a908: 41 82 00 14 beq- ffc0a91c <_Rate_monotonic_Timeout+0x54>
ffc0a90c: 81 23 00 20 lwz r9,32(r3)
ffc0a910: 80 1f 00 08 lwz r0,8(r31)
ffc0a914: 7f 89 00 00 cmpw cr7,r9,r0
ffc0a918: 41 9e 00 6c beq- cr7,ffc0a984 <_Rate_monotonic_Timeout+0xbc>
_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 ) {
ffc0a91c: 80 1f 00 38 lwz r0,56(r31)
ffc0a920: 2f 80 00 01 cmpwi cr7,r0,1
ffc0a924: 41 9e 00 34 beq- cr7,ffc0a958 <_Rate_monotonic_Timeout+0x90>
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
ffc0a928: 38 00 00 04 li r0,4
ffc0a92c: 90 1f 00 38 stw r0,56(r31)
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
ffc0a930: 3d 20 00 00 lis r9,0
ffc0a934: 81 69 28 6c lwz r11,10348(r9)
ffc0a938: 38 0b ff ff addi r0,r11,-1
ffc0a93c: 90 09 28 6c stw r0,10348(r9)
return _Thread_Dispatch_disable_level;
ffc0a940: 80 09 28 6c lwz r0,10348(r9)
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
ffc0a944: 80 01 00 24 lwz r0,36(r1)
ffc0a948: 83 e1 00 1c lwz r31,28(r1)
ffc0a94c: 38 21 00 20 addi r1,r1,32
ffc0a950: 7c 08 03 a6 mtlr r0
ffc0a954: 4e 80 00 20 blr
_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 ) {
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
ffc0a958: 38 00 00 03 li r0,3
ffc0a95c: 90 1f 00 38 stw r0,56(r31)
_Rate_monotonic_Initiate_statistics( the_period );
ffc0a960: 7f e3 fb 78 mr r3,r31
ffc0a964: 4b ff f7 89 bl ffc0a0ec <_Rate_monotonic_Initiate_statistics>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
ffc0a968: 80 1f 00 3c lwz r0,60(r31)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
ffc0a96c: 3c 60 00 00 lis r3,0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
ffc0a970: 90 1f 00 1c stw r0,28(r31)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
ffc0a974: 38 63 2e 68 addi r3,r3,11880
ffc0a978: 38 9f 00 10 addi r4,r31,16
ffc0a97c: 48 00 4c 79 bl ffc0f5f4 <_Watchdog_Insert>
ffc0a980: 4b ff ff b0 b ffc0a930 <_Rate_monotonic_Timeout+0x68>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
ffc0a984: 3c 80 10 03 lis r4,4099
ffc0a988: 60 84 ff f8 ori r4,r4,65528
ffc0a98c: 48 00 33 b5 bl ffc0dd40 <_Thread_Clear_state>
ffc0a990: 4b ff ff d0 b ffc0a960 <_Rate_monotonic_Timeout+0x98>
ffc0c2e8 <_Scheduler_EDF_Allocate>:
#include <rtems/score/wkspace.h>
void *_Scheduler_EDF_Allocate(
Thread_Control *the_thread
)
{
ffc0c2e8: 94 21 ff f0 stwu r1,-16(r1)
ffc0c2ec: 7c 08 02 a6 mflr r0
ffc0c2f0: 93 e1 00 0c stw r31,12(r1)
ffc0c2f4: 7c 7f 1b 78 mr r31,r3
void *sched;
Scheduler_EDF_Per_thread *schinfo;
sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) );
ffc0c2f8: 38 60 00 18 li r3,24
#include <rtems/score/wkspace.h>
void *_Scheduler_EDF_Allocate(
Thread_Control *the_thread
)
{
ffc0c2fc: 90 01 00 14 stw r0,20(r1)
void *sched;
Scheduler_EDF_Per_thread *schinfo;
sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) );
ffc0c300: 48 00 25 a9 bl ffc0e8a8 <_Workspace_Allocate>
if ( sched ) {
ffc0c304: 2c 03 00 00 cmpwi r3,0
ffc0c308: 41 82 00 14 beq- ffc0c31c <_Scheduler_EDF_Allocate+0x34><== NEVER TAKEN
the_thread->scheduler_info = sched;
schinfo = (Scheduler_EDF_Per_thread *)(the_thread->scheduler_info);
schinfo->thread = the_thread;
schinfo->queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
ffc0c30c: 38 00 00 02 li r0,2
Scheduler_EDF_Per_thread *schinfo;
sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) );
if ( sched ) {
the_thread->scheduler_info = sched;
ffc0c310: 90 7f 00 8c stw r3,140(r31)
schinfo = (Scheduler_EDF_Per_thread *)(the_thread->scheduler_info);
schinfo->thread = the_thread;
ffc0c314: 93 e3 00 00 stw r31,0(r3)
schinfo->queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
ffc0c318: 90 03 00 14 stw r0,20(r3)
}
return sched;
}
ffc0c31c: 80 01 00 14 lwz r0,20(r1)
ffc0c320: 83 e1 00 0c lwz r31,12(r1)
ffc0c324: 38 21 00 10 addi r1,r1,16
ffc0c328: 7c 08 03 a6 mtlr r0
ffc0c32c: 4e 80 00 20 blr
ffc0c330 <_Scheduler_EDF_Block>:
#include <rtems/score/thread.h>
void _Scheduler_EDF_Block(
Thread_Control *the_thread
)
{
ffc0c330: 94 21 ff f0 stwu r1,-16(r1)
ffc0c334: 7c 08 02 a6 mflr r0
ffc0c338: 93 c1 00 08 stw r30,8(r1)
RTEMS_INLINE_ROUTINE bool _Thread_Is_heir (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Heir );
ffc0c33c: 3f c0 00 00 lis r30,0
ffc0c340: 3b de 31 c4 addi r30,r30,12740
ffc0c344: 90 01 00 14 stw r0,20(r1)
ffc0c348: 93 e1 00 0c stw r31,12(r1)
ffc0c34c: 7c 7f 1b 78 mr r31,r3
_Scheduler_EDF_Extract( the_thread );
ffc0c350: 48 00 00 bd bl ffc0c40c <_Scheduler_EDF_Extract>
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
ffc0c354: 80 1e 00 10 lwz r0,16(r30)
ffc0c358: 7f 9f 00 00 cmpw cr7,r31,r0
ffc0c35c: 41 9e 00 48 beq- cr7,ffc0c3a4 <_Scheduler_EDF_Block+0x74><== ALWAYS TAKEN
_Scheduler_EDF_Schedule();
if ( _Thread_Is_executing( the_thread ) )
ffc0c360: 80 1e 00 0c lwz r0,12(r30)
ffc0c364: 7f 9f 00 00 cmpw cr7,r31,r0
ffc0c368: 41 9e 00 1c beq- cr7,ffc0c384 <_Scheduler_EDF_Block+0x54><== ALWAYS TAKEN
_Thread_Dispatch_necessary = true;
}
ffc0c36c: 80 01 00 14 lwz r0,20(r1) <== NOT EXECUTED
ffc0c370: 83 c1 00 08 lwz r30,8(r1) <== NOT EXECUTED
ffc0c374: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc0c378: 83 e1 00 0c lwz r31,12(r1) <== NOT EXECUTED
ffc0c37c: 38 21 00 10 addi r1,r1,16 <== NOT EXECUTED
ffc0c380: 4e 80 00 20 blr <== NOT EXECUTED
if ( _Thread_Is_heir( the_thread ) )
_Scheduler_EDF_Schedule();
if ( _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
ffc0c384: 38 00 00 01 li r0,1
}
ffc0c388: 83 e1 00 0c lwz r31,12(r1)
if ( _Thread_Is_heir( the_thread ) )
_Scheduler_EDF_Schedule();
if ( _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
ffc0c38c: 98 1e 00 18 stb r0,24(r30)
}
ffc0c390: 80 01 00 14 lwz r0,20(r1)
ffc0c394: 83 c1 00 08 lwz r30,8(r1)
ffc0c398: 38 21 00 10 addi r1,r1,16
ffc0c39c: 7c 08 03 a6 mtlr r0
ffc0c3a0: 4e 80 00 20 blr
_Scheduler_EDF_Extract( the_thread );
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
_Scheduler_EDF_Schedule();
ffc0c3a4: 48 00 01 fd bl ffc0c5a0 <_Scheduler_EDF_Schedule>
ffc0c3a8: 4b ff ff b8 b ffc0c360 <_Scheduler_EDF_Block+0x30>
ffc0c5d8 <_Scheduler_EDF_Unblock>:
#include <rtems/score/scheduleredf.h>
void _Scheduler_EDF_Unblock(
Thread_Control *the_thread
)
{
ffc0c5d8: 94 21 ff f0 stwu r1,-16(r1)
ffc0c5dc: 7c 08 02 a6 mflr r0
ffc0c5e0: 93 e1 00 0c stw r31,12(r1)
* a context switch.
* Pseudo-ISR case:
* Even if the thread isn't preemptible, if the new heir is
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( _Scheduler_Is_priority_lower_than(
ffc0c5e4: 3f e0 00 00 lis r31,0
ffc0c5e8: 3b ff 31 c4 addi r31,r31,12740
#include <rtems/score/scheduleredf.h>
void _Scheduler_EDF_Unblock(
Thread_Control *the_thread
)
{
ffc0c5ec: 90 01 00 14 stw r0,20(r1)
ffc0c5f0: 93 c1 00 08 stw r30,8(r1)
ffc0c5f4: 7c 7e 1b 78 mr r30,r3
_Scheduler_EDF_Enqueue(the_thread);
ffc0c5f8: 4b ff fd d5 bl ffc0c3cc <_Scheduler_EDF_Enqueue>
ffc0c5fc: 3d 60 00 00 lis r11,0
* a context switch.
* Pseudo-ISR case:
* Even if the thread isn't preemptible, if the new heir is
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( _Scheduler_Is_priority_lower_than(
ffc0c600: 81 3f 00 10 lwz r9,16(r31)
ffc0c604: 80 0b 21 10 lwz r0,8464(r11)
ffc0c608: 80 69 00 14 lwz r3,20(r9)
ffc0c60c: 80 9e 00 14 lwz r4,20(r30)
ffc0c610: 7c 09 03 a6 mtctr r0
ffc0c614: 4e 80 04 21 bctrl
ffc0c618: 2f 83 00 00 cmpwi cr7,r3,0
ffc0c61c: 41 9c 00 1c blt- cr7,ffc0c638 <_Scheduler_EDF_Unblock+0x60>
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
}
}
ffc0c620: 80 01 00 14 lwz r0,20(r1)
ffc0c624: 83 c1 00 08 lwz r30,8(r1)
ffc0c628: 7c 08 03 a6 mtlr r0
ffc0c62c: 83 e1 00 0c lwz r31,12(r1)
ffc0c630: 38 21 00 10 addi r1,r1,16
ffc0c634: 4e 80 00 20 blr
*/
if ( _Scheduler_Is_priority_lower_than(
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
ffc0c638: 81 3f 00 0c lwz r9,12(r31)
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( _Scheduler_Is_priority_lower_than(
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
ffc0c63c: 93 df 00 10 stw r30,16(r31)
if ( _Thread_Executing->is_preemptible ||
ffc0c640: 88 09 00 74 lbz r0,116(r9)
ffc0c644: 2f 80 00 00 cmpwi cr7,r0,0
ffc0c648: 41 9e 00 24 beq- cr7,ffc0c66c <_Scheduler_EDF_Unblock+0x94><== NEVER TAKEN
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
ffc0c64c: 38 00 00 01 li r0,1
ffc0c650: 98 1f 00 18 stb r0,24(r31)
}
}
ffc0c654: 80 01 00 14 lwz r0,20(r1)
ffc0c658: 83 c1 00 08 lwz r30,8(r1)
ffc0c65c: 7c 08 03 a6 mtlr r0
ffc0c660: 83 e1 00 0c lwz r31,12(r1)
ffc0c664: 38 21 00 10 addi r1,r1,16
ffc0c668: 4e 80 00 20 blr
*/
if ( _Scheduler_Is_priority_lower_than(
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
ffc0c66c: 80 1e 00 14 lwz r0,20(r30) <== NOT EXECUTED
ffc0c670: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc0c674: 40 be ff ac bne- cr7,ffc0c620 <_Scheduler_EDF_Unblock+0x48><== NOT EXECUTED
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
ffc0c678: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc0c67c: 98 1f 00 18 stb r0,24(r31) <== NOT EXECUTED
ffc0c680: 4b ff ff d4 b ffc0c654 <_Scheduler_EDF_Unblock+0x7c> <== NOT EXECUTED
ffc0c684 <_Scheduler_EDF_Update>:
#include <rtems/score/thread.h>
void _Scheduler_EDF_Update(
Thread_Control *the_thread
)
{
ffc0c684: 94 21 ff e8 stwu r1,-24(r1)
ffc0c688: 7c 08 02 a6 mflr r0
ffc0c68c: 90 01 00 1c stw r0,28(r1)
ffc0c690: 93 c1 00 10 stw r30,16(r1)
Scheduler_EDF_Per_thread *sched_info =
ffc0c694: 83 c3 00 8c lwz r30,140(r3)
#include <rtems/score/thread.h>
void _Scheduler_EDF_Update(
Thread_Control *the_thread
)
{
ffc0c698: 93 e1 00 14 stw r31,20(r1)
ffc0c69c: 7c 7f 1b 78 mr r31,r3
Scheduler_EDF_Per_thread *sched_info =
(Scheduler_EDF_Per_thread*)the_thread->scheduler_info;
RBTree_Node *the_node = &(sched_info->Node);
if (sched_info->queue_state == SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN) {
ffc0c6a0: 80 1e 00 14 lwz r0,20(r30)
#include <rtems/score/thread.h>
void _Scheduler_EDF_Update(
Thread_Control *the_thread
)
{
ffc0c6a4: 93 a1 00 0c stw r29,12(r1)
Scheduler_EDF_Per_thread *sched_info =
(Scheduler_EDF_Per_thread*)the_thread->scheduler_info;
RBTree_Node *the_node = &(sched_info->Node);
if (sched_info->queue_state == SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN) {
ffc0c6a8: 2f 80 00 02 cmpwi cr7,r0,2
ffc0c6ac: 41 9e 00 28 beq- cr7,ffc0c6d4 <_Scheduler_EDF_Update+0x50>
the_thread->real_priority = the_thread->Start.initial_priority;
the_thread->current_priority = the_thread->Start.initial_priority;
sched_info->queue_state = SCHEDULER_EDF_QUEUE_STATE_NOT_PRESENTLY;
}
if ( sched_info->queue_state == SCHEDULER_EDF_QUEUE_STATE_YES ) {
ffc0c6b0: 2f 80 00 01 cmpwi cr7,r0,1
ffc0c6b4: 41 9e 00 58 beq- cr7,ffc0c70c <_Scheduler_EDF_Update+0x88><== NEVER TAKEN
if ( _Thread_Executing->is_preemptible ||
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
}
}
}
ffc0c6b8: 80 01 00 1c lwz r0,28(r1)
ffc0c6bc: 83 a1 00 0c lwz r29,12(r1)
ffc0c6c0: 7c 08 03 a6 mtlr r0
ffc0c6c4: 83 c1 00 10 lwz r30,16(r1)
ffc0c6c8: 83 e1 00 14 lwz r31,20(r1)
ffc0c6cc: 38 21 00 18 addi r1,r1,24
ffc0c6d0: 4e 80 00 20 blr
(Scheduler_EDF_Per_thread*)the_thread->scheduler_info;
RBTree_Node *the_node = &(sched_info->Node);
if (sched_info->queue_state == SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN) {
/* Shifts the priority to the region of background tasks. */
the_thread->Start.initial_priority |= (SCHEDULER_EDF_PRIO_MSB);
ffc0c6d4: 80 03 00 b0 lwz r0,176(r3)
if ( _Thread_Executing->is_preemptible ||
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
}
}
}
ffc0c6d8: 83 a1 00 0c lwz r29,12(r1)
(Scheduler_EDF_Per_thread*)the_thread->scheduler_info;
RBTree_Node *the_node = &(sched_info->Node);
if (sched_info->queue_state == SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN) {
/* Shifts the priority to the region of background tasks. */
the_thread->Start.initial_priority |= (SCHEDULER_EDF_PRIO_MSB);
ffc0c6dc: 64 00 80 00 oris r0,r0,32768
if ( _Thread_Executing->is_preemptible ||
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
}
}
}
ffc0c6e0: 83 e1 00 14 lwz r31,20(r1)
(Scheduler_EDF_Per_thread*)the_thread->scheduler_info;
RBTree_Node *the_node = &(sched_info->Node);
if (sched_info->queue_state == SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN) {
/* Shifts the priority to the region of background tasks. */
the_thread->Start.initial_priority |= (SCHEDULER_EDF_PRIO_MSB);
ffc0c6e4: 90 03 00 b0 stw r0,176(r3)
the_thread->real_priority = the_thread->Start.initial_priority;
ffc0c6e8: 90 03 00 18 stw r0,24(r3)
the_thread->current_priority = the_thread->Start.initial_priority;
ffc0c6ec: 90 03 00 14 stw r0,20(r3)
sched_info->queue_state = SCHEDULER_EDF_QUEUE_STATE_NOT_PRESENTLY;
ffc0c6f0: 38 00 00 00 li r0,0
ffc0c6f4: 90 1e 00 14 stw r0,20(r30)
if ( _Thread_Executing->is_preemptible ||
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
}
}
}
ffc0c6f8: 80 01 00 1c lwz r0,28(r1)
ffc0c6fc: 83 c1 00 10 lwz r30,16(r1)
ffc0c700: 38 21 00 18 addi r1,r1,24
ffc0c704: 7c 08 03 a6 mtlr r0
ffc0c708: 4e 80 00 20 blr
the_thread->current_priority = the_thread->Start.initial_priority;
sched_info->queue_state = SCHEDULER_EDF_QUEUE_STATE_NOT_PRESENTLY;
}
if ( sched_info->queue_state == SCHEDULER_EDF_QUEUE_STATE_YES ) {
_RBTree_Extract(&_Scheduler_EDF_Ready_queue, the_node);
ffc0c70c: 3f a0 00 00 lis r29,0 <== NOT EXECUTED
Thread_Control *the_thread
)
{
Scheduler_EDF_Per_thread *sched_info =
(Scheduler_EDF_Per_thread*)the_thread->scheduler_info;
RBTree_Node *the_node = &(sched_info->Node);
ffc0c710: 3b de 00 04 addi r30,r30,4 <== NOT EXECUTED
the_thread->current_priority = the_thread->Start.initial_priority;
sched_info->queue_state = SCHEDULER_EDF_QUEUE_STATE_NOT_PRESENTLY;
}
if ( sched_info->queue_state == SCHEDULER_EDF_QUEUE_STATE_YES ) {
_RBTree_Extract(&_Scheduler_EDF_Ready_queue, the_node);
ffc0c714: 3b bd 31 e8 addi r29,r29,12776 <== NOT EXECUTED
ffc0c718: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc0c71c: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc0c720: 48 00 5e 61 bl ffc12580 <_RBTree_Extract> <== NOT EXECUTED
_RBTree_Insert(&_Scheduler_EDF_Ready_queue, the_node);
ffc0c724: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc0c728: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc0c72c: 48 00 61 91 bl ffc128bc <_RBTree_Insert> <== NOT EXECUTED
_Scheduler_EDF_Schedule();
ffc0c730: 4b ff fe 71 bl ffc0c5a0 <_Scheduler_EDF_Schedule> <== NOT EXECUTED
if ( _Thread_Executing != _Thread_Heir ) {
ffc0c734: 3d 20 00 00 lis r9,0 <== NOT EXECUTED
ffc0c738: 39 29 31 c4 addi r9,r9,12740 <== NOT EXECUTED
ffc0c73c: 81 69 00 0c lwz r11,12(r9) <== NOT EXECUTED
ffc0c740: 80 09 00 10 lwz r0,16(r9) <== NOT EXECUTED
ffc0c744: 7f 8b 00 00 cmpw cr7,r11,r0 <== NOT EXECUTED
ffc0c748: 41 be ff 70 beq- cr7,ffc0c6b8 <_Scheduler_EDF_Update+0x34><== NOT EXECUTED
if ( _Thread_Executing->is_preemptible ||
ffc0c74c: 88 0b 00 74 lbz r0,116(r11) <== NOT EXECUTED
ffc0c750: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc0c754: 40 9e 00 10 bne- cr7,ffc0c764 <_Scheduler_EDF_Update+0xe0><== NOT EXECUTED
ffc0c758: 80 1f 00 14 lwz r0,20(r31) <== NOT EXECUTED
ffc0c75c: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc0c760: 40 be ff 58 bne- cr7,ffc0c6b8 <_Scheduler_EDF_Update+0x34><== NOT EXECUTED
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
ffc0c764: 38 00 00 01 li r0,1 <== NOT EXECUTED
}
}
}
ffc0c768: 83 a1 00 0c lwz r29,12(r1) <== NOT EXECUTED
_Scheduler_EDF_Schedule();
if ( _Thread_Executing != _Thread_Heir ) {
if ( _Thread_Executing->is_preemptible ||
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
ffc0c76c: 98 09 00 18 stb r0,24(r9) <== NOT EXECUTED
}
}
}
ffc0c770: 80 01 00 1c lwz r0,28(r1) <== NOT EXECUTED
ffc0c774: 83 c1 00 10 lwz r30,16(r1) <== NOT EXECUTED
ffc0c778: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc0c77c: 83 e1 00 14 lwz r31,20(r1) <== NOT EXECUTED
ffc0c780: 38 21 00 18 addi r1,r1,24 <== NOT EXECUTED
ffc0c784: 4e 80 00 20 blr <== NOT EXECUTED
ffc0c788 <_Scheduler_EDF_Yield>:
#include <rtems/score/scheduler.h>
#include <rtems/score/scheduleredf.h>
#include <rtems/score/thread.h>
void _Scheduler_EDF_Yield(void)
{
ffc0c788: 94 21 ff e0 stwu r1,-32(r1) <== NOT EXECUTED
ffc0c78c: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc0c790: 93 c1 00 18 stw r30,24(r1) <== NOT EXECUTED
Scheduler_EDF_Per_thread *first_info;
RBTree_Node *first_node;
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
ffc0c794: 3f c0 00 00 lis r30,0 <== NOT EXECUTED
ffc0c798: 3b de 31 c4 addi r30,r30,12740 <== NOT EXECUTED
#include <rtems/score/scheduler.h>
#include <rtems/score/scheduleredf.h>
#include <rtems/score/thread.h>
void _Scheduler_EDF_Yield(void)
{
ffc0c79c: 90 01 00 24 stw r0,36(r1) <== NOT EXECUTED
ffc0c7a0: 93 a1 00 14 stw r29,20(r1) <== NOT EXECUTED
Scheduler_EDF_Per_thread *first_info;
RBTree_Node *first_node;
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
ffc0c7a4: 83 be 00 0c lwz r29,12(r30) <== NOT EXECUTED
#include <rtems/score/scheduler.h>
#include <rtems/score/scheduleredf.h>
#include <rtems/score/thread.h>
void _Scheduler_EDF_Yield(void)
{
ffc0c7a8: 93 61 00 0c stw r27,12(r1) <== NOT EXECUTED
ffc0c7ac: 93 81 00 10 stw r28,16(r1) <== NOT EXECUTED
ffc0c7b0: 93 e1 00 1c stw r31,28(r1) <== NOT EXECUTED
Scheduler_EDF_Per_thread *first_info;
RBTree_Node *first_node;
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
Scheduler_EDF_Per_thread *executing_info =
ffc0c7b4: 83 7d 00 8c lwz r27,140(r29) <== NOT EXECUTED
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0c7b8: 7f 80 00 a6 mfmsr r28 <== NOT EXECUTED
ffc0c7bc: 7c 10 42 a6 mfsprg r0,0 <== NOT EXECUTED
ffc0c7c0: 7f 80 00 78 andc r0,r28,r0 <== NOT EXECUTED
ffc0c7c4: 7c 00 01 24 mtmsr r0 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _RBTree_Has_only_one_node(
const RBTree_Control *the_rbtree
)
{
if(!the_rbtree) return NULL; /* TODO: expected behavior? */
return (the_rbtree->root->child[RBT_LEFT] == NULL && the_rbtree->root->child[RBT_RIGHT] == NULL);
ffc0c7c8: 3f e0 00 00 lis r31,0 <== NOT EXECUTED
ffc0c7cc: 3b ff 31 e8 addi r31,r31,12776 <== NOT EXECUTED
ffc0c7d0: 81 3f 00 04 lwz r9,4(r31) <== NOT EXECUTED
ffc0c7d4: 80 09 00 04 lwz r0,4(r9) <== NOT EXECUTED
ffc0c7d8: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc0c7dc: 41 9e 00 68 beq- cr7,ffc0c844 <_Scheduler_EDF_Yield+0xbc><== NOT EXECUTED
(Scheduler_EDF_Per_thread *) executing->scheduler_info;
RBTree_Node *executing_node = &(executing_info->Node);
ffc0c7e0: 3b 7b 00 04 addi r27,r27,4 <== NOT EXECUTED
if ( !_RBTree_Has_only_one_node(&_Scheduler_EDF_Ready_queue) ) {
/*
* The RBTree has more than one node, enqueue behind the tasks
* with the same priority in case there are such ones.
*/
_RBTree_Extract( &_Scheduler_EDF_Ready_queue, executing_node );
ffc0c7e4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc0c7e8: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc0c7ec: 48 00 5d 95 bl ffc12580 <_RBTree_Extract> <== NOT EXECUTED
_RBTree_Insert( &_Scheduler_EDF_Ready_queue, executing_node );
ffc0c7f0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc0c7f4: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc0c7f8: 48 00 60 c5 bl ffc128bc <_RBTree_Insert> <== NOT EXECUTED
static inline void ppc_interrupt_flash( uint32_t level )
{
uint32_t current_level;
__asm__ volatile (
ffc0c7fc: 7c 00 00 a6 mfmsr r0 <== NOT EXECUTED
ffc0c800: 7f 80 01 24 mtmsr r28 <== NOT EXECUTED
ffc0c804: 7c 00 01 24 mtmsr r0 <== NOT EXECUTED
_ISR_Flash( level );
if ( _Thread_Is_heir( executing ) ) {
ffc0c808: 80 1e 00 10 lwz r0,16(r30) <== NOT EXECUTED
ffc0c80c: 7f 9d 00 00 cmpw cr7,r29,r0 <== NOT EXECUTED
ffc0c810: 41 9e 00 50 beq- cr7,ffc0c860 <_Scheduler_EDF_Yield+0xd8><== NOT EXECUTED
_Thread_Heir = first_info->thread;
}
_Thread_Dispatch_necessary = true;
}
else if ( !_Thread_Is_heir( executing ) )
_Thread_Dispatch_necessary = true;
ffc0c814: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc0c818: 98 1e 00 18 stb r0,24(r30) <== NOT EXECUTED
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0c81c: 7f 80 01 24 mtmsr r28 <== NOT EXECUTED
_ISR_Enable( level );
}
ffc0c820: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
ffc0c824: 83 61 00 0c lwz r27,12(r1) <== NOT EXECUTED
ffc0c828: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc0c82c: 83 81 00 10 lwz r28,16(r1) <== NOT EXECUTED
ffc0c830: 83 a1 00 14 lwz r29,20(r1) <== NOT EXECUTED
ffc0c834: 83 c1 00 18 lwz r30,24(r1) <== NOT EXECUTED
ffc0c838: 83 e1 00 1c lwz r31,28(r1) <== NOT EXECUTED
ffc0c83c: 38 21 00 20 addi r1,r1,32 <== NOT EXECUTED
ffc0c840: 4e 80 00 20 blr <== NOT EXECUTED
ffc0c844: 80 09 00 08 lwz r0,8(r9) <== NOT EXECUTED
ffc0c848: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc0c84c: 40 9e ff 94 bne+ cr7,ffc0c7e0 <_Scheduler_EDF_Yield+0x58><== NOT EXECUTED
_RBTree_Container_of(first_node, Scheduler_EDF_Per_thread, Node);
_Thread_Heir = first_info->thread;
}
_Thread_Dispatch_necessary = true;
}
else if ( !_Thread_Is_heir( executing ) )
ffc0c850: 80 1e 00 10 lwz r0,16(r30) <== NOT EXECUTED
ffc0c854: 7f 9d 00 00 cmpw cr7,r29,r0 <== NOT EXECUTED
ffc0c858: 40 9e ff bc bne+ cr7,ffc0c814 <_Scheduler_EDF_Yield+0x8c><== NOT EXECUTED
ffc0c85c: 4b ff ff c0 b ffc0c81c <_Scheduler_EDF_Yield+0x94> <== NOT EXECUTED
_RBTree_Insert( &_Scheduler_EDF_Ready_queue, executing_node );
_ISR_Flash( level );
if ( _Thread_Is_heir( executing ) ) {
first_node = _RBTree_Peek( &_Scheduler_EDF_Ready_queue, RBT_LEFT );
ffc0c860: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc0c864: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc0c868: 48 00 60 69 bl ffc128d0 <_RBTree_Peek> <== NOT EXECUTED
first_info =
_RBTree_Container_of(first_node, Scheduler_EDF_Per_thread, Node);
_Thread_Heir = first_info->thread;
ffc0c86c: 80 03 ff fc lwz r0,-4(r3) <== NOT EXECUTED
ffc0c870: 90 1e 00 10 stw r0,16(r30) <== NOT EXECUTED
ffc0c874: 4b ff ff a0 b ffc0c814 <_Scheduler_EDF_Yield+0x8c> <== NOT EXECUTED
ffc0b8c0 <_Scheduler_priority_Block>:
)
{
Scheduler_priority_Per_thread *sched_info;
Chain_Control *ready;
sched_info = (Scheduler_priority_Per_thread *) the_thread->scheduler_info;
ffc0b8c0: 81 63 00 8c lwz r11,140(r3)
ready = sched_info->ready_chain;
ffc0b8c4: 81 2b 00 00 lwz r9,0(r11)
if ( _Chain_Has_only_one_node( ready ) ) {
ffc0b8c8: 81 49 00 00 lwz r10,0(r9)
ffc0b8cc: 80 09 00 08 lwz r0,8(r9)
ffc0b8d0: 7f 8a 00 00 cmpw cr7,r10,r0
ffc0b8d4: 41 9e 00 a4 beq- cr7,ffc0b978 <_Scheduler_priority_Block+0xb8>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
ffc0b8d8: 81 63 00 00 lwz r11,0(r3)
previous = the_node->previous;
ffc0b8dc: 81 23 00 04 lwz r9,4(r3)
next->previous = previous;
ffc0b8e0: 91 2b 00 04 stw r9,4(r11)
previous->next = next;
ffc0b8e4: 91 69 00 00 stw r11,0(r9)
RTEMS_INLINE_ROUTINE bool _Thread_Is_heir (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Heir );
ffc0b8e8: 3d 20 00 00 lis r9,0
ffc0b8ec: 39 29 31 44 addi r9,r9,12612
{
_Scheduler_priority_Ready_queue_extract( the_thread );
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
ffc0b8f0: 80 09 00 10 lwz r0,16(r9)
ffc0b8f4: 7f 83 00 00 cmpw cr7,r3,r0
ffc0b8f8: 41 9e 00 1c beq- cr7,ffc0b914 <_Scheduler_priority_Block+0x54>
_Scheduler_priority_Schedule_body();
if ( _Thread_Is_executing( the_thread ) )
ffc0b8fc: 80 09 00 0c lwz r0,12(r9)
ffc0b900: 7f 83 00 00 cmpw cr7,r3,r0
ffc0b904: 4c be 00 20 bnelr+ cr7
_Thread_Dispatch_necessary = true;
ffc0b908: 38 00 00 01 li r0,1
ffc0b90c: 98 09 00 18 stb r0,24(r9)
ffc0b910: 4e 80 00 20 blr
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 );
ffc0b914: 3c a0 00 00 lis r5,0
* @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
ffc0b918: 3d 40 00 00 lis r10,0
ffc0b91c: 81 65 28 4c lwz r11,10316(r5)
ffc0b920: 81 4a 20 e0 lwz r10,8416(r10)
ffc0b924: 7d 66 00 34 cntlzw r6,r11
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
ffc0b928: 3c e0 00 00 lis r7,0
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 );
ffc0b92c: 91 65 28 4c stw r11,10316(r5)
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
ffc0b930: 38 e7 31 80 addi r7,r7,12672
ffc0b934: 54 c8 10 3a rlwinm r8,r6,2,0,29
ffc0b938: 7c 07 40 2e lwzx r0,r7,r8
ffc0b93c: 7c 0b 00 34 cntlzw r11,r0
return (_Priority_Bits_index( major ) << 4) +
ffc0b940: 54 c6 20 36 rlwinm r6,r6,4,0,27
{
Priority_bit_map_Control minor;
Priority_bit_map_Control major;
_Bitfield_Find_first_bit( _Priority_Major_bit_map, major );
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
ffc0b944: 7c 07 41 2e stwx r0,r7,r8
return (_Priority_Bits_index( major ) << 4) +
ffc0b948: 7d 66 5a 14 add r11,r6,r11
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
ffc0b94c: 1d 6b 00 0c mulli r11,r11,12
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
ffc0b950: 7c 0a 58 2e lwzx r0,r10,r11
ffc0b954: 7d 0a 5a 14 add r8,r10,r11
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
ffc0b958: 39 68 00 04 addi r11,r8,4
ffc0b95c: 7f 80 58 00 cmpw cr7,r0,r11
ffc0b960: 41 9e 00 60 beq- cr7,ffc0b9c0 <_Scheduler_priority_Block+0x100><== NEVER TAKEN
*
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
ffc0b964: 90 09 00 10 stw r0,16(r9)
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
_Scheduler_priority_Schedule_body();
if ( _Thread_Is_executing( the_thread ) )
ffc0b968: 80 09 00 0c lwz r0,12(r9)
ffc0b96c: 7f 83 00 00 cmpw cr7,r3,r0
ffc0b970: 4c be 00 20 bnelr+ cr7
ffc0b974: 4b ff ff 94 b ffc0b908 <_Scheduler_priority_Block+0x48>
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor &= the_priority_map->block_minor;
ffc0b978: 81 4b 00 04 lwz r10,4(r11)
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 );
ffc0b97c: 39 09 00 04 addi r8,r9,4
ffc0b980: 80 0b 00 14 lwz r0,20(r11)
ffc0b984: 80 ea 00 00 lwz r7,0(r10)
head->next = tail;
ffc0b988: 91 09 00 00 stw r8,0(r9)
head->previous = NULL;
ffc0b98c: 39 00 00 00 li r8,0
ffc0b990: 7c e0 00 38 and r0,r7,r0
if ( *the_priority_map->minor == 0 )
ffc0b994: 2f 80 00 00 cmpwi cr7,r0,0
ffc0b998: 91 09 00 04 stw r8,4(r9)
tail->previous = head;
ffc0b99c: 91 29 00 08 stw r9,8(r9)
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor &= the_priority_map->block_minor;
ffc0b9a0: 90 0a 00 00 stw r0,0(r10)
if ( *the_priority_map->minor == 0 )
ffc0b9a4: 40 be ff 44 bne- cr7,ffc0b8e8 <_Scheduler_priority_Block+0x28>
_Priority_Major_bit_map &= the_priority_map->block_major;
ffc0b9a8: 3d 20 00 00 lis r9,0
ffc0b9ac: 80 0b 00 10 lwz r0,16(r11)
ffc0b9b0: 81 49 28 4c lwz r10,10316(r9)
ffc0b9b4: 7d 40 00 38 and r0,r10,r0
ffc0b9b8: 90 09 28 4c stw r0,10316(r9)
ffc0b9bc: 4b ff ff 2c b ffc0b8e8 <_Scheduler_priority_Block+0x28>
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
return NULL;
ffc0b9c0: 38 00 00 00 li r0,0 <== NOT EXECUTED
*
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
ffc0b9c4: 90 09 00 10 stw r0,16(r9) <== NOT EXECUTED
ffc0b9c8: 4b ff ff a0 b ffc0b968 <_Scheduler_priority_Block+0xa8><== NOT EXECUTED
ffc0bba4 <_Scheduler_priority_Schedule>:
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 );
ffc0bba4: 3c c0 00 00 lis r6,0
* @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
ffc0bba8: 3d 60 00 00 lis r11,0
ffc0bbac: 81 26 28 4c lwz r9,10316(r6)
ffc0bbb0: 81 6b 20 e0 lwz r11,8416(r11)
ffc0bbb4: 7d 27 00 34 cntlzw r7,r9
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
ffc0bbb8: 3d 00 00 00 lis r8,0
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 );
ffc0bbbc: 91 26 28 4c stw r9,10316(r6)
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
ffc0bbc0: 39 08 31 80 addi r8,r8,12672
ffc0bbc4: 54 ea 10 3a rlwinm r10,r7,2,0,29
ffc0bbc8: 7c 08 50 2e lwzx r0,r8,r10
ffc0bbcc: 7c 06 00 34 cntlzw r6,r0
return (_Priority_Bits_index( major ) << 4) +
ffc0bbd0: 54 e9 20 36 rlwinm r9,r7,4,0,27
{
Priority_bit_map_Control minor;
Priority_bit_map_Control major;
_Bitfield_Find_first_bit( _Priority_Major_bit_map, major );
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
ffc0bbd4: 7c 08 51 2e stwx r0,r8,r10
return (_Priority_Bits_index( major ) << 4) +
ffc0bbd8: 7d 29 32 14 add r9,r9,r6
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
ffc0bbdc: 1d 29 00 0c mulli r9,r9,12
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
ffc0bbe0: 7c 0b 48 2e lwzx r0,r11,r9
ffc0bbe4: 7d 4b 4a 14 add r10,r11,r9
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
ffc0bbe8: 39 2a 00 04 addi r9,r10,4
ffc0bbec: 7f 80 48 00 cmpw cr7,r0,r9
ffc0bbf0: 41 9e 00 10 beq- cr7,ffc0bc00 <_Scheduler_priority_Schedule+0x5c><== NEVER TAKEN
*
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
ffc0bbf4: 3d 20 00 00 lis r9,0
ffc0bbf8: 90 09 31 54 stw r0,12628(r9)
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Schedule(void)
{
_Scheduler_priority_Schedule_body();
}
ffc0bbfc: 4e 80 00 20 blr
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
return NULL;
ffc0bc00: 38 00 00 00 li r0,0 <== NOT EXECUTED
*
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
ffc0bc04: 3d 20 00 00 lis r9,0 <== NOT EXECUTED
ffc0bc08: 90 09 31 54 stw r0,12628(r9) <== NOT EXECUTED
ffc0bc0c: 4e 80 00 20 blr <== NOT EXECUTED
ffc0bc10 <_Scheduler_priority_Tick>:
#include <rtems/system.h>
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Tick( void )
{
ffc0bc10: 7c 08 02 a6 mflr r0
ffc0bc14: 94 21 ff f0 stwu r1,-16(r1)
Thread_Control *executing;
executing = _Thread_Executing;
ffc0bc18: 3d 20 00 00 lis r9,0
#include <rtems/system.h>
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Tick( void )
{
ffc0bc1c: 90 01 00 14 stw r0,20(r1)
Thread_Control *executing;
executing = _Thread_Executing;
ffc0bc20: 80 69 31 50 lwz r3,12624(r9)
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
ffc0bc24: 88 03 00 74 lbz r0,116(r3)
ffc0bc28: 2f 80 00 00 cmpwi cr7,r0,0
ffc0bc2c: 41 9e 00 2c beq- cr7,ffc0bc58 <_Scheduler_priority_Tick+0x48>
return;
if ( !_States_Is_ready( executing->current_state ) )
ffc0bc30: 80 03 00 10 lwz r0,16(r3)
ffc0bc34: 2f 80 00 00 cmpwi cr7,r0,0
ffc0bc38: 40 9e 00 20 bne- cr7,ffc0bc58 <_Scheduler_priority_Tick+0x48>
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
ffc0bc3c: 80 03 00 7c lwz r0,124(r3)
ffc0bc40: 2b 80 00 01 cmplwi cr7,r0,1
ffc0bc44: 41 9c 00 14 blt- cr7,ffc0bc58 <_Scheduler_priority_Tick+0x48>
ffc0bc48: 2b 80 00 02 cmplwi cr7,r0,2
ffc0bc4c: 40 9d 00 40 ble- cr7,ffc0bc8c <_Scheduler_priority_Tick+0x7c>
ffc0bc50: 2f 80 00 03 cmpwi cr7,r0,3
ffc0bc54: 41 9e 00 14 beq- cr7,ffc0bc68 <_Scheduler_priority_Tick+0x58><== ALWAYS TAKEN
if ( --executing->cpu_time_budget == 0 )
(*executing->budget_callout)( executing );
break;
#endif
}
}
ffc0bc58: 80 01 00 14 lwz r0,20(r1)
ffc0bc5c: 38 21 00 10 addi r1,r1,16
ffc0bc60: 7c 08 03 a6 mtlr r0
ffc0bc64: 4e 80 00 20 blr
}
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
ffc0bc68: 81 23 00 78 lwz r9,120(r3)
ffc0bc6c: 38 09 ff ff addi r0,r9,-1
ffc0bc70: 2f 80 00 00 cmpwi cr7,r0,0
ffc0bc74: 90 03 00 78 stw r0,120(r3)
ffc0bc78: 40 9e ff e0 bne+ cr7,ffc0bc58 <_Scheduler_priority_Tick+0x48>
(*executing->budget_callout)( executing );
ffc0bc7c: 80 03 00 80 lwz r0,128(r3)
ffc0bc80: 7c 09 03 a6 mtctr r0
ffc0bc84: 4e 80 04 21 bctrl
ffc0bc88: 4b ff ff d0 b ffc0bc58 <_Scheduler_priority_Tick+0x48>
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 ) {
ffc0bc8c: 81 23 00 78 lwz r9,120(r3)
ffc0bc90: 38 09 ff ff addi r0,r9,-1
ffc0bc94: 2f 80 00 00 cmpwi cr7,r0,0
ffc0bc98: 90 03 00 78 stw r0,120(r3)
ffc0bc9c: 41 9d ff bc bgt+ cr7,ffc0bc58 <_Scheduler_priority_Tick+0x48>
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield();
ffc0bca0: 3d 20 00 00 lis r9,0
ffc0bca4: 90 61 00 08 stw r3,8(r1)
ffc0bca8: 80 09 20 ec lwz r0,8428(r9)
ffc0bcac: 7c 09 03 a6 mtctr r0
ffc0bcb0: 4e 80 04 21 bctrl
* 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;
ffc0bcb4: 3d 20 00 00 lis r9,0
ffc0bcb8: 80 09 28 08 lwz r0,10248(r9)
ffc0bcbc: 80 61 00 08 lwz r3,8(r1)
ffc0bcc0: 90 03 00 78 stw r0,120(r3)
ffc0bcc4: 4b ff ff 94 b ffc0bc58 <_Scheduler_priority_Tick+0x48>
ffc0c5e8 <_Scheduler_simple_Ready_queue_enqueue_first>:
{
Chain_Control *ready;
Chain_Node *the_node;
Thread_Control *current;
ready = (Chain_Control *)_Scheduler.information;
ffc0c5e8: 3d 20 00 00 lis r9,0
*/
for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) {
current = (Thread_Control *) the_node;
/* break when AT HEAD OF (or PAST) our priority */
if ( the_thread->current_priority <= current->current_priority ) {
ffc0c5ec: 81 63 00 14 lwz r11,20(r3)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc0c5f0: 81 29 20 e0 lwz r9,8416(r9)
ffc0c5f4: 81 29 00 00 lwz r9,0(r9)
ffc0c5f8: 80 09 00 14 lwz r0,20(r9)
ffc0c5fc: 7f 80 58 40 cmplw cr7,r0,r11
ffc0c600: 40 9c 00 14 bge- cr7,ffc0c614 <_Scheduler_simple_Ready_queue_enqueue_first+0x2c>
* Do NOT need to check for end of chain because there is always
* at least one task on the ready chain -- the IDLE task. It can
* never block, should never attempt to obtain a semaphore or mutex,
* and thus will always be there.
*/
for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) {
ffc0c604: 81 29 00 00 lwz r9,0(r9)
current = (Thread_Control *) the_node;
/* break when AT HEAD OF (or PAST) our priority */
if ( the_thread->current_priority <= current->current_priority ) {
ffc0c608: 80 09 00 14 lwz r0,20(r9)
ffc0c60c: 7f 80 58 40 cmplw cr7,r0,r11
ffc0c610: 41 9c ff f4 blt+ cr7,ffc0c604 <_Scheduler_simple_Ready_queue_enqueue_first+0x1c><== NEVER TAKEN
current = (Thread_Control *)current->Object.Node.previous;
ffc0c614: 81 29 00 04 lwz r9,4(r9)
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
ffc0c618: 81 69 00 00 lwz r11,0(r9)
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
ffc0c61c: 91 23 00 04 stw r9,4(r3)
before_node = after_node->next;
after_node->next = the_node;
ffc0c620: 90 69 00 00 stw r3,0(r9)
the_node->next = before_node;
before_node->previous = the_node;
ffc0c624: 90 6b 00 04 stw r3,4(r11)
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
the_node->next = before_node;
ffc0c628: 91 63 00 00 stw r11,0(r3)
}
}
/* enqueue */
_Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
}
ffc0c62c: 4e 80 00 20 blr
ffc0bec4 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
ffc0bec4: 94 21 ff e8 stwu r1,-24(r1)
ffc0bec8: 7c 08 02 a6 mflr r0
ffc0becc: 90 01 00 1c stw r0,28(r1)
ffc0bed0: 93 e1 00 14 stw r31,20(r1)
ffc0bed4: 7c 7f 1b 78 mr r31,r3
ffc0bed8: 93 81 00 08 stw r28,8(r1)
ffc0bedc: 7c bc 2b 78 mr r28,r5
ffc0bee0: 93 a1 00 0c stw r29,12(r1)
ffc0bee4: 93 c1 00 10 stw r30,16(r1)
ffc0bee8: 7c 9e 23 78 mr r30,r4
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
ffc0beec: 83 a3 00 10 lwz r29,16(r3)
/*
* 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 );
ffc0bef0: 48 00 11 71 bl ffc0d060 <_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 )
ffc0bef4: 80 1f 00 14 lwz r0,20(r31)
ffc0bef8: 7f 80 f0 00 cmpw cr7,r0,r30
ffc0befc: 41 9e 00 10 beq- cr7,ffc0bf0c <_Thread_Change_priority+0x48>
_Thread_Set_priority( the_thread, new_priority );
ffc0bf00: 7f e3 fb 78 mr r3,r31
ffc0bf04: 7f c4 f3 78 mr r4,r30
ffc0bf08: 48 00 10 b1 bl ffc0cfb8 <_Thread_Set_priority>
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0bf0c: 7f c0 00 a6 mfmsr r30
ffc0bf10: 7c 10 42 a6 mfsprg r0,0
ffc0bf14: 7f c0 00 78 andc r0,r30,r0
ffc0bf18: 7c 00 01 24 mtmsr r0
/*
* 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;
ffc0bf1c: 80 1f 00 10 lwz r0,16(r31)
if ( state != STATES_TRANSIENT ) {
ffc0bf20: 2f 80 00 04 cmpwi cr7,r0,4
ffc0bf24: 41 9e 00 88 beq- cr7,ffc0bfac <_Thread_Change_priority+0xe8>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
ffc0bf28: 73 a9 00 04 andi. r9,r29,4
ffc0bf2c: 41 82 00 38 beq- ffc0bf64 <_Thread_Change_priority+0xa0><== ALWAYS TAKEN
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0bf30: 7f c0 01 24 mtmsr r30 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
ffc0bf34: 3d 20 00 03 lis r9,3 <== NOT EXECUTED
ffc0bf38: 61 29 be e0 ori r9,r9,48864 <== NOT EXECUTED
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
if ( _States_Is_waiting_on_thread_queue( state ) ) {
ffc0bf3c: 7c 0b 48 39 and. r11,r0,r9 <== NOT EXECUTED
ffc0bf40: 40 82 00 40 bne- ffc0bf80 <_Thread_Change_priority+0xbc><== NOT EXECUTED
if ( !_Thread_Is_executing_also_the_heir() &&
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
_ISR_Enable( level );
}
ffc0bf44: 80 01 00 1c lwz r0,28(r1)
ffc0bf48: 83 81 00 08 lwz r28,8(r1)
ffc0bf4c: 7c 08 03 a6 mtlr r0
ffc0bf50: 83 a1 00 0c lwz r29,12(r1)
ffc0bf54: 83 c1 00 10 lwz r30,16(r1)
ffc0bf58: 83 e1 00 14 lwz r31,20(r1)
ffc0bf5c: 38 21 00 18 addi r1,r1,24
ffc0bf60: 4e 80 00 20 blr
RTEMS_INLINE_ROUTINE States_Control _States_Clear (
States_Control states_to_clear,
States_Control current_state
)
{
return (current_state & ~states_to_clear);
ffc0bf64: 54 09 07 b8 rlwinm r9,r0,0,30,28
*/
state = the_thread->current_state;
if ( state != STATES_TRANSIENT ) {
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
ffc0bf68: 91 3f 00 10 stw r9,16(r31)
ffc0bf6c: 7f c0 01 24 mtmsr r30
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
ffc0bf70: 3d 20 00 03 lis r9,3
ffc0bf74: 61 29 be e0 ori r9,r9,48864
_ISR_Enable( level );
if ( _States_Is_waiting_on_thread_queue( state ) ) {
ffc0bf78: 7c 0b 48 39 and. r11,r0,r9
ffc0bf7c: 41 82 ff c8 beq+ ffc0bf44 <_Thread_Change_priority+0x80>
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
ffc0bf80: 80 7f 00 44 lwz r3,68(r31)
ffc0bf84: 7f e4 fb 78 mr r4,r31
ffc0bf88: 48 00 0f 35 bl ffc0cebc <_Thread_queue_Requeue>
if ( !_Thread_Is_executing_also_the_heir() &&
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
_ISR_Enable( level );
}
ffc0bf8c: 80 01 00 1c lwz r0,28(r1)
ffc0bf90: 83 81 00 08 lwz r28,8(r1)
ffc0bf94: 7c 08 03 a6 mtlr r0
ffc0bf98: 83 a1 00 0c lwz r29,12(r1)
ffc0bf9c: 83 c1 00 10 lwz r30,16(r1)
ffc0bfa0: 83 e1 00 14 lwz r31,20(r1)
ffc0bfa4: 38 21 00 18 addi r1,r1,24
ffc0bfa8: 4e 80 00 20 blr
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
ffc0bfac: 73 bd 00 04 andi. r29,r29,4
ffc0bfb0: 41 82 00 74 beq- ffc0c024 <_Thread_Change_priority+0x160><== ALWAYS TAKEN
ffc0bfb4: 3f a0 00 00 lis r29,0 <== NOT EXECUTED
ffc0bfb8: 3b bd 20 e0 addi r29,r29,8416 <== NOT EXECUTED
static inline void ppc_interrupt_flash( uint32_t level )
{
uint32_t current_level;
__asm__ volatile (
ffc0bfbc: 7c 00 00 a6 mfmsr r0
ffc0bfc0: 7f c0 01 24 mtmsr r30
ffc0bfc4: 7c 00 01 24 mtmsr r0
* 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();
ffc0bfc8: 80 1d 00 08 lwz r0,8(r29)
ffc0bfcc: 7c 09 03 a6 mtctr r0
ffc0bfd0: 4e 80 04 21 bctrl
* is also the heir thread, and false otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )
{
return ( _Thread_Executing == _Thread_Heir );
ffc0bfd4: 3d 20 00 00 lis r9,0
ffc0bfd8: 39 29 31 44 addi r9,r9,12612
ffc0bfdc: 81 69 00 0c lwz r11,12(r9)
* 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() &&
ffc0bfe0: 80 09 00 10 lwz r0,16(r9)
ffc0bfe4: 7f 8b 00 00 cmpw cr7,r11,r0
ffc0bfe8: 41 9e 00 18 beq- cr7,ffc0c000 <_Thread_Change_priority+0x13c>
ffc0bfec: 88 0b 00 74 lbz r0,116(r11)
ffc0bff0: 2f 80 00 00 cmpwi cr7,r0,0
ffc0bff4: 41 9e 00 0c beq- cr7,ffc0c000 <_Thread_Change_priority+0x13c>
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
ffc0bff8: 38 00 00 01 li r0,1
ffc0bffc: 98 09 00 18 stb r0,24(r9)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0c000: 7f c0 01 24 mtmsr r30
_ISR_Enable( level );
}
ffc0c004: 80 01 00 1c lwz r0,28(r1)
ffc0c008: 83 81 00 08 lwz r28,8(r1)
ffc0c00c: 7c 08 03 a6 mtlr r0
ffc0c010: 83 a1 00 0c lwz r29,12(r1)
ffc0c014: 83 c1 00 10 lwz r30,16(r1)
ffc0c018: 83 e1 00 14 lwz r31,20(r1)
ffc0c01c: 38 21 00 18 addi r1,r1,24
ffc0c020: 4e 80 00 20 blr
* 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 );
if ( prepend_it )
ffc0c024: 2f 9c 00 00 cmpwi cr7,r28,0
* 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 );
ffc0c028: 93 bf 00 10 stw r29,16(r31)
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
ffc0c02c: 3f a0 00 00 lis r29,0
ffc0c030: 3b bd 20 e0 addi r29,r29,8416
if ( prepend_it )
ffc0c034: 41 9e 00 18 beq- cr7,ffc0c04c <_Thread_Change_priority+0x188>
ffc0c038: 80 1d 00 28 lwz r0,40(r29)
ffc0c03c: 7f e3 fb 78 mr r3,r31
ffc0c040: 7c 09 03 a6 mtctr r0
ffc0c044: 4e 80 04 21 bctrl
ffc0c048: 4b ff ff 74 b ffc0bfbc <_Thread_Change_priority+0xf8>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
ffc0c04c: 80 1d 00 24 lwz r0,36(r29)
ffc0c050: 7f e3 fb 78 mr r3,r31
ffc0c054: 7c 09 03 a6 mtctr r0
ffc0c058: 4e 80 04 21 bctrl
ffc0c05c: 4b ff ff 60 b ffc0bfbc <_Thread_Change_priority+0xf8>
ffc0c2d8 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
ffc0c2d8: 94 21 ff e8 stwu r1,-24(r1)
ffc0c2dc: 7c 08 02 a6 mflr r0
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
ffc0c2e0: 38 81 00 08 addi r4,r1,8
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
ffc0c2e4: 90 01 00 1c stw r0,28(r1)
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
ffc0c2e8: 48 00 02 3d bl ffc0c524 <_Thread_Get>
switch ( location ) {
ffc0c2ec: 80 01 00 08 lwz r0,8(r1)
ffc0c2f0: 2f 80 00 00 cmpwi cr7,r0,0
ffc0c2f4: 40 9e 00 24 bne- cr7,ffc0c318 <_Thread_Delay_ended+0x40><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
ffc0c2f8: 3c 80 10 00 lis r4,4096
ffc0c2fc: 60 84 00 18 ori r4,r4,24
ffc0c300: 4b ff fd 61 bl ffc0c060 <_Thread_Clear_state>
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
ffc0c304: 3d 20 00 00 lis r9,0
ffc0c308: 81 69 28 0c lwz r11,10252(r9)
ffc0c30c: 38 0b ff ff addi r0,r11,-1
ffc0c310: 90 09 28 0c stw r0,10252(r9)
return _Thread_Dispatch_disable_level;
ffc0c314: 80 09 28 0c lwz r0,10252(r9)
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
ffc0c318: 80 01 00 1c lwz r0,28(r1)
ffc0c31c: 38 21 00 18 addi r1,r1,24
ffc0c320: 7c 08 03 a6 mtlr r0
ffc0c324: 4e 80 00 20 blr
ffc0c328 <_Thread_Dispatch>:
* INTERRUPT LATENCY:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
ffc0c328: 94 21 ff c8 stwu r1,-56(r1)
ffc0c32c: 7c 08 02 a6 mflr r0
ffc0c330: 93 21 00 1c stw r25,28(r1)
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc0c334: 3f 20 00 00 lis r25,0
ffc0c338: 81 39 28 0c lwz r9,10252(r25)
ffc0c33c: 90 01 00 3c stw r0,60(r1)
ffc0c340: 38 09 00 01 addi r0,r9,1
ffc0c344: 90 19 28 0c stw r0,10252(r25)
ffc0c348: 93 01 00 18 stw r24,24(r1)
return _Thread_Dispatch_disable_level;
ffc0c34c: 80 19 28 0c lwz r0,10252(r25)
ffc0c350: 93 41 00 20 stw r26,32(r1)
ffc0c354: 93 61 00 24 stw r27,36(r1)
ffc0c358: 93 81 00 28 stw r28,40(r1)
ffc0c35c: 93 a1 00 2c stw r29,44(r1)
ffc0c360: 93 c1 00 30 stw r30,48(r1)
ffc0c364: 93 e1 00 34 stw r31,52(r1)
#endif
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
ffc0c368: 3f a0 00 00 lis r29,0
ffc0c36c: 3b bd 31 44 addi r29,r29,12612
ffc0c370: 83 fd 00 0c lwz r31,12(r29)
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0c374: 7c 00 00 a6 mfmsr r0
ffc0c378: 7d 30 42 a6 mfsprg r9,0
ffc0c37c: 7c 09 48 78 andc r9,r0,r9
ffc0c380: 7d 20 01 24 mtmsr r9
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
ffc0c384: 89 3d 00 18 lbz r9,24(r29)
ffc0c388: 2f 89 00 00 cmpwi cr7,r9,0
ffc0c38c: 41 9e 01 14 beq- cr7,ffc0c4a0 <_Thread_Dispatch+0x178>
heir = _Thread_Heir;
ffc0c390: 83 dd 00 10 lwz r30,16(r29)
_Thread_Dispatch_necessary = false;
ffc0c394: 39 20 00 00 li r9,0
ffc0c398: 99 3d 00 18 stb r9,24(r29)
/*
* 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 )
ffc0c39c: 7f 9f f0 00 cmpw cr7,r31,r30
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
heir = _Thread_Heir;
_Thread_Dispatch_necessary = false;
_Thread_Executing = heir;
ffc0c3a0: 93 dd 00 0c stw r30,12(r29)
/*
* 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 )
ffc0c3a4: 41 9e 00 fc beq- cr7,ffc0c4a0 <_Thread_Dispatch+0x178>
ffc0c3a8: 3f 80 00 00 lis r28,0
ffc0c3ac: 3b 7d 00 1c addi r27,r29,28
ffc0c3b0: 3b 9c 28 20 addi r28,r28,10272
#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;
ffc0c3b4: 3f 00 00 00 lis r24,0
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
heir = _Thread_Heir;
_Thread_Dispatch_necessary = false;
ffc0c3b8: 3b 40 00 00 li r26,0
ffc0c3bc: 48 00 00 cc b ffc0c488 <_Thread_Dispatch+0x160>
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0c3c0: 7c 00 01 24 mtmsr r0
_ISR_Enable( level );
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
ffc0c3c4: 38 61 00 10 addi r3,r1,16
ffc0c3c8: 48 00 4b 35 bl ffc10efc <_TOD_Get_uptime>
_Timestamp_Subtract(
ffc0c3cc: 7f 63 db 78 mr r3,r27
ffc0c3d0: 38 81 00 10 addi r4,r1,16
ffc0c3d4: 38 a1 00 08 addi r5,r1,8
ffc0c3d8: 48 00 0f 15 bl ffc0d2ec <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
ffc0c3dc: 38 81 00 08 addi r4,r1,8
ffc0c3e0: 38 7f 00 84 addi r3,r31,132
ffc0c3e4: 48 00 0e ad bl ffc0d290 <_Timespec_Add_to>
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
ffc0c3e8: 81 3c 00 00 lwz r9,0(r28)
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
_Thread_Time_of_last_context_switch = uptime;
ffc0c3ec: 81 41 00 10 lwz r10,16(r1)
if ( _Thread_libc_reent ) {
executing->libc_reent = *_Thread_libc_reent;
*_Thread_libc_reent = heir->libc_reent;
}
_User_extensions_Thread_switch( executing, heir );
ffc0c3f0: 7f e3 fb 78 mr r3,r31
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
ffc0c3f4: 2f 89 00 00 cmpwi cr7,r9,0
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
_Thread_Time_of_last_context_switch = uptime;
ffc0c3f8: 81 61 00 14 lwz r11,20(r1)
if ( _Thread_libc_reent ) {
executing->libc_reent = *_Thread_libc_reent;
*_Thread_libc_reent = heir->libc_reent;
}
_User_extensions_Thread_switch( executing, heir );
ffc0c3fc: 7f c4 f3 78 mr r4,r30
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
_Thread_Time_of_last_context_switch = uptime;
ffc0c400: 91 5d 00 1c stw r10,28(r29)
ffc0c404: 91 7d 00 20 stw r11,32(r29)
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
ffc0c408: 41 9e 00 14 beq- cr7,ffc0c41c <_Thread_Dispatch+0xf4> <== NEVER TAKEN
executing->libc_reent = *_Thread_libc_reent;
ffc0c40c: 80 09 00 00 lwz r0,0(r9)
ffc0c410: 90 1f 01 2c stw r0,300(r31)
*_Thread_libc_reent = heir->libc_reent;
ffc0c414: 80 1e 01 2c lwz r0,300(r30)
ffc0c418: 90 09 00 00 stw r0,0(r9)
}
_User_extensions_Thread_switch( executing, heir );
ffc0c41c: 48 00 13 65 bl ffc0d780 <_User_extensions_Thread_switch>
* operations.
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH != TRUE )
if ( executing->fp_context != NULL )
ffc0c420: 80 1f 01 28 lwz r0,296(r31)
_Context_Save_fp( &executing->fp_context );
ffc0c424: 38 7f 01 28 addi r3,r31,296
* operations.
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH != TRUE )
if ( executing->fp_context != NULL )
ffc0c428: 2f 80 00 00 cmpwi cr7,r0,0
ffc0c42c: 41 9e 00 08 beq- cr7,ffc0c434 <_Thread_Dispatch+0x10c>
_Context_Save_fp( &executing->fp_context );
ffc0c430: 48 01 21 91 bl ffc1e5c0 <_CPU_Context_save_fp>
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
ffc0c434: 38 7f 00 c8 addi r3,r31,200
ffc0c438: 38 9e 00 c8 addi r4,r30,200
ffc0c43c: 48 01 23 05 bl ffc1e740 <_CPU_Context_switch>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
_Context_Restore_fp( &executing->fp_context );
_Thread_Allocated_fp = executing;
}
#else
if ( executing->fp_context != NULL )
ffc0c440: 80 1f 01 28 lwz r0,296(r31)
_Context_Restore_fp( &executing->fp_context );
ffc0c444: 38 7f 01 28 addi r3,r31,296
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
_Context_Restore_fp( &executing->fp_context );
_Thread_Allocated_fp = executing;
}
#else
if ( executing->fp_context != NULL )
ffc0c448: 2f 80 00 00 cmpwi cr7,r0,0
ffc0c44c: 41 9e 00 08 beq- cr7,ffc0c454 <_Thread_Dispatch+0x12c>
_Context_Restore_fp( &executing->fp_context );
ffc0c450: 48 01 22 31 bl ffc1e680 <_CPU_Context_restore_fp>
#endif
#endif
executing = _Thread_Executing;
ffc0c454: 83 fd 00 0c lwz r31,12(r29)
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0c458: 7c 00 00 a6 mfmsr r0
ffc0c45c: 7d 30 42 a6 mfsprg r9,0
ffc0c460: 7c 09 48 78 andc r9,r0,r9
ffc0c464: 7d 20 01 24 mtmsr r9
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
ffc0c468: 89 3d 00 18 lbz r9,24(r29)
ffc0c46c: 2f 89 00 00 cmpwi cr7,r9,0
ffc0c470: 41 9e 00 30 beq- cr7,ffc0c4a0 <_Thread_Dispatch+0x178>
heir = _Thread_Heir;
ffc0c474: 83 dd 00 10 lwz r30,16(r29)
_Thread_Dispatch_necessary = false;
ffc0c478: 9b 5d 00 18 stb r26,24(r29)
/*
* 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 )
ffc0c47c: 7f 9e f8 00 cmpw cr7,r30,r31
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
heir = _Thread_Heir;
_Thread_Dispatch_necessary = false;
_Thread_Executing = heir;
ffc0c480: 93 dd 00 0c stw r30,12(r29)
/*
* 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 )
ffc0c484: 41 9e 00 1c beq- cr7,ffc0c4a0 <_Thread_Dispatch+0x178> <== NEVER TAKEN
*/
#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 )
ffc0c488: 81 3e 00 7c lwz r9,124(r30)
ffc0c48c: 2f 89 00 01 cmpwi cr7,r9,1
ffc0c490: 40 9e ff 30 bne+ cr7,ffc0c3c0 <_Thread_Dispatch+0x98>
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
ffc0c494: 81 38 28 08 lwz r9,10248(r24)
ffc0c498: 91 3e 00 78 stw r9,120(r30)
ffc0c49c: 4b ff ff 24 b ffc0c3c0 <_Thread_Dispatch+0x98>
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0c4a0: 7c 00 01 24 mtmsr r0
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
ffc0c4a4: 81 39 28 0c lwz r9,10252(r25)
ffc0c4a8: 38 09 ff ff addi r0,r9,-1
ffc0c4ac: 90 19 28 0c stw r0,10252(r25)
return _Thread_Dispatch_disable_level;
ffc0c4b0: 80 19 28 0c lwz r0,10252(r25)
_ISR_Enable( level );
_Thread_Unnest_dispatch();
_API_extensions_Run_postswitch();
ffc0c4b4: 4b ff db 75 bl ffc0a028 <_API_extensions_Run_postswitch>
}
ffc0c4b8: 80 01 00 3c lwz r0,60(r1)
ffc0c4bc: 83 01 00 18 lwz r24,24(r1)
ffc0c4c0: 7c 08 03 a6 mtlr r0
ffc0c4c4: 83 21 00 1c lwz r25,28(r1)
ffc0c4c8: 83 41 00 20 lwz r26,32(r1)
ffc0c4cc: 83 61 00 24 lwz r27,36(r1)
ffc0c4d0: 83 81 00 28 lwz r28,40(r1)
ffc0c4d4: 83 a1 00 2c lwz r29,44(r1)
ffc0c4d8: 83 c1 00 30 lwz r30,48(r1)
ffc0c4dc: 83 e1 00 34 lwz r31,52(r1)
ffc0c4e0: 38 21 00 38 addi r1,r1,56
ffc0c4e4: 4e 80 00 20 blr
ffc13b2c <_Thread_Handler>:
* Input parameters: NONE
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
ffc13b2c: 94 21 ff f0 stwu r1,-16(r1)
ffc13b30: 7c 08 02 a6 mflr r0
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static bool doneConstructors;
bool doCons;
#endif
executing = _Thread_Executing;
ffc13b34: 3d 20 00 00 lis r9,0
* Input parameters: NONE
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
ffc13b38: 90 01 00 14 stw r0,20(r1)
ffc13b3c: 93 e1 00 0c stw r31,12(r1)
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static bool doneConstructors;
bool doCons;
#endif
executing = _Thread_Executing;
ffc13b40: 83 e9 31 50 lwz r31,12624(r9)
* Input parameters: NONE
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
ffc13b44: 93 c1 00 08 stw r30,8(r1)
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
ffc13b48: 81 3f 00 ac lwz r9,172(r31)
}
static inline void _CPU_ISR_Set_level( uint32_t level )
{
register unsigned int msr;
_CPU_MSR_GET(msr);
ffc13b4c: 38 00 00 00 li r0,0
ffc13b50: 7c 00 00 a6 mfmsr r0
if (!(level & CPU_MODES_INTERRUPT_MASK)) {
ffc13b54: 71 2b 00 01 andi. r11,r9,1
static inline uint32_t ppc_interrupt_get_disable_mask( void )
{
uint32_t mask;
__asm__ volatile (
ffc13b58: 7d 30 42 a6 mfsprg r9,0
ffc13b5c: 40 82 00 5c bne- ffc13bb8 <_Thread_Handler+0x8c>
msr |= ppc_interrupt_get_disable_mask();
ffc13b60: 7d 20 03 78 or r0,r9,r0
}
else {
msr &= ~ppc_interrupt_get_disable_mask();
}
_CPU_MSR_SET(msr);
ffc13b64: 7c 00 01 24 mtmsr r0
doCons = !doneConstructors
&& _Objects_Get_API( executing->Object.id ) != OBJECTS_INTERNAL_API;
if (doCons)
doneConstructors = true;
#else
doCons = !doneConstructors;
ffc13b68: 3d 20 00 00 lis r9,0
ffc13b6c: 8b c9 29 f8 lbz r30,10744(r9)
doneConstructors = true;
ffc13b70: 38 00 00 01 li r0,1
/*
* 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 );
ffc13b74: 7f e3 fb 78 mr r3,r31
&& _Objects_Get_API( executing->Object.id ) != OBJECTS_INTERNAL_API;
if (doCons)
doneConstructors = true;
#else
doCons = !doneConstructors;
doneConstructors = true;
ffc13b78: 98 09 29 f8 stb r0,10744(r9)
/*
* 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 );
ffc13b7c: 4b ff 98 c9 bl ffc0d444 <_User_extensions_Thread_begin>
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
ffc13b80: 4b ff 89 69 bl ffc0c4e8 <_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 (doCons) /* && (volatile void *)_init) */ {
ffc13b84: 2f 9e 00 00 cmpwi cr7,r30,0
ffc13b88: 41 9e 00 38 beq- cr7,ffc13bc0 <_Thread_Handler+0x94>
_Thread_Enable_dispatch();
#endif
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
ffc13b8c: 80 1f 00 94 lwz r0,148(r31)
ffc13b90: 2f 80 00 00 cmpwi cr7,r0,0
ffc13b94: 41 9e 00 34 beq- cr7,ffc13bc8 <_Thread_Handler+0x9c>
(*(Thread_Entry_numeric) executing->Start.entry_point)(
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
ffc13b98: 2f 80 00 01 cmpwi cr7,r0,1
ffc13b9c: 41 9e 00 44 beq- cr7,ffc13be0 <_Thread_Handler+0xb4> <== ALWAYS TAKEN
* 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 );
ffc13ba0: 7f e3 fb 78 mr r3,r31
ffc13ba4: 4b ff 99 15 bl ffc0d4b8 <_User_extensions_Thread_exitted>
_Internal_error_Occurred(
ffc13ba8: 38 60 00 00 li r3,0
ffc13bac: 38 80 00 01 li r4,1
ffc13bb0: 38 a0 00 05 li r5,5
ffc13bb4: 4b ff 72 0d bl ffc0adc0 <_Internal_error_Occurred>
_CPU_MSR_GET(msr);
if (!(level & CPU_MODES_INTERRUPT_MASK)) {
msr |= ppc_interrupt_get_disable_mask();
}
else {
msr &= ~ppc_interrupt_get_disable_mask();
ffc13bb8: 7c 00 48 78 andc r0,r0,r9
ffc13bbc: 4b ff ff a8 b ffc13b64 <_Thread_Handler+0x38>
* _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 (doCons) /* && (volatile void *)_init) */ {
INIT_NAME ();
ffc13bc0: 48 00 bd bd bl ffc1f97c <_init>
ffc13bc4: 4b ff ff c8 b ffc13b8c <_Thread_Handler+0x60>
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
ffc13bc8: 80 1f 00 90 lwz r0,144(r31)
ffc13bcc: 80 7f 00 9c lwz r3,156(r31)
ffc13bd0: 7c 09 03 a6 mtctr r0
ffc13bd4: 4e 80 04 21 bctrl
#endif
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
executing->Wait.return_argument =
ffc13bd8: 90 7f 00 28 stw r3,40(r31)
ffc13bdc: 4b ff ff c4 b ffc13ba0 <_Thread_Handler+0x74>
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
executing->Wait.return_argument =
(*(Thread_Entry_pointer) executing->Start.entry_point)(
ffc13be0: 80 1f 00 90 lwz r0,144(r31)
ffc13be4: 80 7f 00 98 lwz r3,152(r31)
ffc13be8: 7c 09 03 a6 mtctr r0
ffc13bec: 4e 80 04 21 bctrl
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
executing->Wait.return_argument =
ffc13bf0: 90 7f 00 28 stw r3,40(r31)
ffc13bf4: 4b ff ff ac b ffc13ba0 <_Thread_Handler+0x74>
ffc0c5f4 <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
ffc0c5f4: 94 21 ff c8 stwu r1,-56(r1)
ffc0c5f8: 7c 08 02 a6 mflr r0
ffc0c5fc: 93 c1 00 30 stw r30,48(r1)
if ( !actual_stack_size || actual_stack_size < stack_size )
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
#else
if ( !stack_area ) {
ffc0c600: 7c be 2b 79 mr. r30,r5
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
ffc0c604: 90 01 00 3c stw r0,60(r1)
/*
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
ffc0c608: 38 00 00 00 li r0,0
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
ffc0c60c: 93 61 00 24 stw r27,36(r1)
ffc0c610: 7d 3b 4b 78 mr r27,r9
ffc0c614: 81 21 00 48 lwz r9,72(r1)
ffc0c618: 92 e1 00 14 stw r23,20(r1)
ffc0c61c: 93 21 00 1c stw r25,28(r1)
ffc0c620: 7d 59 53 78 mr r25,r10
ffc0c624: 93 81 00 28 stw r28,40(r1)
ffc0c628: 7d 1c 43 78 mr r28,r8
ffc0c62c: 93 a1 00 2c stw r29,44(r1)
ffc0c630: 7c 7d 1b 78 mr r29,r3
ffc0c634: 93 e1 00 34 stw r31,52(r1)
ffc0c638: 7c 9f 23 78 mr r31,r4
ffc0c63c: 93 01 00 18 stw r24,24(r1)
ffc0c640: 93 41 00 20 stw r26,32(r1)
ffc0c644: 82 e9 00 00 lwz r23,0(r9)
/*
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
ffc0c648: 90 04 01 30 stw r0,304(r4)
ffc0c64c: 90 04 01 34 stw r0,308(r4)
extensions_area = NULL;
the_thread->libc_reent = NULL;
ffc0c650: 90 04 01 2c stw r0,300(r4)
if ( !actual_stack_size || actual_stack_size < stack_size )
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
#else
if ( !stack_area ) {
ffc0c654: 41 82 01 d0 beq- ffc0c824 <_Thread_Initialize+0x230>
stack = the_thread->Start.stack;
the_thread->Start.core_allocated_stack = true;
} else {
stack = stack_area;
actual_stack_size = stack_size;
the_thread->Start.core_allocated_stack = false;
ffc0c658: 98 04 00 b4 stb r0,180(r4)
ffc0c65c: 7c c0 33 78 mr r0,r6
/*
* Allocate the floating point area for this thread
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
ffc0c660: 2f 87 00 00 cmpwi cr7,r7,0
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
ffc0c664: 93 df 00 bc stw r30,188(r31)
extensions_area = NULL;
the_thread->libc_reent = NULL;
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
fp_area = NULL;
ffc0c668: 3b 40 00 00 li r26,0
the_stack->size = size;
ffc0c66c: 90 1f 00 b8 stw r0,184(r31)
/*
* Allocate the floating point area for this thread
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
ffc0c670: 40 9e 01 48 bne- cr7,ffc0c7b8 <_Thread_Initialize+0x1c4>
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
ffc0c674: 3f c0 00 00 lis r30,0
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
if ( !fp_area )
goto failed;
fp_area = _Context_Fp_start( fp_area, 0 );
}
the_thread->fp_context = fp_area;
ffc0c678: 93 5f 01 28 stw r26,296(r31)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
ffc0c67c: 38 00 00 00 li r0,0
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
ffc0c680: 81 3e 28 2c lwz r9,10284(r30)
if ( !fp_area )
goto failed;
fp_area = _Context_Fp_start( fp_area, 0 );
}
the_thread->fp_context = fp_area;
the_thread->Start.fp_context = fp_area;
ffc0c684: 93 5f 00 c0 stw r26,192(r31)
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
ffc0c688: 2f 89 00 00 cmpwi cr7,r9,0
ffc0c68c: 90 1f 00 50 stw r0,80(r31)
the_watchdog->routine = routine;
ffc0c690: 90 1f 00 64 stw r0,100(r31)
the_watchdog->id = id;
ffc0c694: 90 1f 00 68 stw r0,104(r31)
the_watchdog->user_data = user_data;
ffc0c698: 90 1f 00 6c stw r0,108(r31)
ffc0c69c: 40 9e 01 38 bne- cr7,ffc0c7d4 <_Thread_Initialize+0x1e0>
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
goto failed;
}
the_thread->extensions = (void **) extensions_area;
ffc0c6a0: 91 3f 01 38 stw r9,312(r31)
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
extensions_area = NULL;
ffc0c6a4: 3b 00 00 00 li r24,0
the_thread->Start.is_preemptible = is_preemptible;
the_thread->Start.budget_algorithm = budget_algorithm;
the_thread->Start.budget_callout = budget_callout;
switch ( budget_algorithm ) {
ffc0c6a8: 2f 99 00 02 cmpwi cr7,r25,2
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
the_thread->Start.budget_algorithm = budget_algorithm;
the_thread->Start.budget_callout = budget_callout;
ffc0c6ac: 80 01 00 40 lwz r0,64(r1)
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
ffc0c6b0: 9b 7f 00 a0 stb r27,160(r31)
the_thread->Start.budget_algorithm = budget_algorithm;
ffc0c6b4: 93 3f 00 a4 stw r25,164(r31)
the_thread->Start.budget_callout = budget_callout;
ffc0c6b8: 90 1f 00 a8 stw r0,168(r31)
switch ( budget_algorithm ) {
ffc0c6bc: 40 be 00 10 bne+ cr7,ffc0c6cc <_Thread_Initialize+0xd8>
case THREAD_CPU_BUDGET_ALGORITHM_NONE:
case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE)
case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
ffc0c6c0: 3d 20 00 00 lis r9,0
ffc0c6c4: 80 09 28 08 lwz r0,10248(r9)
ffc0c6c8: 90 1f 00 78 stw r0,120(r31)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
ffc0c6cc: 80 01 00 44 lwz r0,68(r1)
*/
RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate(
Thread_Control *the_thread
)
{
return _Scheduler.Operations.allocate( the_thread );
ffc0c6d0: 3d 20 00 00 lis r9,0
the_thread->current_state = STATES_DORMANT;
the_thread->Wait.queue = NULL;
ffc0c6d4: 3b c0 00 00 li r30,0
the_thread->resource_count = 0;
the_thread->real_priority = priority;
ffc0c6d8: 93 9f 00 18 stw r28,24(r31)
ffc0c6dc: 7f e3 fb 78 mr r3,r31
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
ffc0c6e0: 90 1f 00 ac stw r0,172(r31)
the_thread->current_state = STATES_DORMANT;
ffc0c6e4: 38 00 00 01 li r0,1
ffc0c6e8: 90 1f 00 10 stw r0,16(r31)
ffc0c6ec: 80 09 20 f8 lwz r0,8440(r9)
the_thread->Wait.queue = NULL;
ffc0c6f0: 93 df 00 44 stw r30,68(r31)
ffc0c6f4: 7c 09 03 a6 mtctr r0
the_thread->resource_count = 0;
ffc0c6f8: 93 df 00 1c stw r30,28(r31)
the_thread->real_priority = priority;
the_thread->Start.initial_priority = priority;
ffc0c6fc: 93 9f 00 b0 stw r28,176(r31)
ffc0c700: 4e 80 04 21 bctrl
sched =_Scheduler_Allocate( the_thread );
if ( !sched )
ffc0c704: 7c 7b 1b 79 mr. r27,r3
ffc0c708: 41 82 00 40 beq- ffc0c748 <_Thread_Initialize+0x154>
goto failed;
_Thread_Set_priority( the_thread, priority );
ffc0c70c: 7f e3 fb 78 mr r3,r31
ffc0c710: 7f 84 e3 78 mr r4,r28
ffc0c714: 48 00 08 a5 bl ffc0cfb8 <_Thread_Set_priority>
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
ffc0c718: a0 1f 00 0a lhz r0,10(r31)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
ffc0c71c: 81 3d 00 1c lwz r9,28(r29)
* enabled when we get here. We want to be able to run the
* user extensions with dispatching enabled. The Allocator
* Mutex provides sufficient protection to let the user extensions
* run safely.
*/
extension_status = _User_extensions_Thread_create( the_thread );
ffc0c720: 7f e3 fb 78 mr r3,r31
ffc0c724: 54 00 10 3a rlwinm r0,r0,2,0,29
/*
* Initialize the CPU usage statistics
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &the_thread->cpu_time_used );
ffc0c728: 93 df 00 84 stw r30,132(r31)
ffc0c72c: 93 df 00 88 stw r30,136(r31)
ffc0c730: 7f e9 01 2e stwx r31,r9,r0
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
ffc0c734: 92 ff 00 0c stw r23,12(r31)
* enabled when we get here. We want to be able to run the
* user extensions with dispatching enabled. The Allocator
* Mutex provides sufficient protection to let the user extensions
* run safely.
*/
extension_status = _User_extensions_Thread_create( the_thread );
ffc0c738: 48 00 0e 81 bl ffc0d5b8 <_User_extensions_Thread_create>
if ( extension_status )
ffc0c73c: 2f 83 00 00 cmpwi cr7,r3,0
return true;
ffc0c740: 38 60 00 01 li r3,1
* user extensions with dispatching enabled. The Allocator
* Mutex provides sufficient protection to let the user extensions
* run safely.
*/
extension_status = _User_extensions_Thread_create( the_thread );
if ( extension_status )
ffc0c744: 40 9e 00 40 bne- cr7,ffc0c784 <_Thread_Initialize+0x190>
return true;
failed:
_Workspace_Free( the_thread->libc_reent );
ffc0c748: 80 7f 01 2c lwz r3,300(r31)
ffc0c74c: 48 00 14 d9 bl ffc0dc24 <_Workspace_Free>
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
_Workspace_Free( the_thread->API_Extensions[i] );
ffc0c750: 80 7f 01 30 lwz r3,304(r31)
ffc0c754: 48 00 14 d1 bl ffc0dc24 <_Workspace_Free>
ffc0c758: 80 7f 01 34 lwz r3,308(r31)
ffc0c75c: 48 00 14 c9 bl ffc0dc24 <_Workspace_Free>
_Workspace_Free( extensions_area );
ffc0c760: 7f 03 c3 78 mr r3,r24
ffc0c764: 48 00 14 c1 bl ffc0dc24 <_Workspace_Free>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Workspace_Free( fp_area );
ffc0c768: 7f 43 d3 78 mr r3,r26
ffc0c76c: 48 00 14 b9 bl ffc0dc24 <_Workspace_Free>
#endif
_Workspace_Free( sched );
ffc0c770: 7f 63 db 78 mr r3,r27
ffc0c774: 48 00 14 b1 bl ffc0dc24 <_Workspace_Free>
_Thread_Stack_Free( the_thread );
ffc0c778: 7f e3 fb 78 mr r3,r31
ffc0c77c: 48 00 09 e9 bl ffc0d164 <_Thread_Stack_Free>
return false;
ffc0c780: 38 60 00 00 li r3,0
}
ffc0c784: 80 01 00 3c lwz r0,60(r1)
ffc0c788: 82 e1 00 14 lwz r23,20(r1)
ffc0c78c: 7c 08 03 a6 mtlr r0
ffc0c790: 83 01 00 18 lwz r24,24(r1)
ffc0c794: 83 21 00 1c lwz r25,28(r1)
ffc0c798: 83 41 00 20 lwz r26,32(r1)
ffc0c79c: 83 61 00 24 lwz r27,36(r1)
ffc0c7a0: 83 81 00 28 lwz r28,40(r1)
ffc0c7a4: 83 a1 00 2c lwz r29,44(r1)
ffc0c7a8: 83 c1 00 30 lwz r30,48(r1)
ffc0c7ac: 83 e1 00 34 lwz r31,52(r1)
ffc0c7b0: 38 21 00 38 addi r1,r1,56
ffc0c7b4: 4e 80 00 20 blr
/*
* Allocate the floating point area for this thread
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
ffc0c7b8: 38 60 01 08 li r3,264
ffc0c7bc: 48 00 14 35 bl ffc0dbf0 <_Workspace_Allocate>
if ( !fp_area )
ffc0c7c0: 7c 7a 1b 79 mr. r26,r3
ffc0c7c4: 40 82 fe b0 bne+ ffc0c674 <_Thread_Initialize+0x80>
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
extensions_area = NULL;
ffc0c7c8: 3b 00 00 00 li r24,0
size_t actual_stack_size = 0;
void *stack = NULL;
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
void *fp_area;
#endif
void *sched = NULL;
ffc0c7cc: 3b 60 00 00 li r27,0
ffc0c7d0: 4b ff ff 78 b ffc0c748 <_Thread_Initialize+0x154>
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
extensions_area = _Workspace_Allocate(
ffc0c7d4: 39 29 00 01 addi r9,r9,1
ffc0c7d8: 55 23 10 3a rlwinm r3,r9,2,0,29
ffc0c7dc: 48 00 14 15 bl ffc0dbf0 <_Workspace_Allocate>
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
ffc0c7e0: 7c 78 1b 79 mr. r24,r3
ffc0c7e4: 41 82 00 84 beq- ffc0c868 <_Thread_Initialize+0x274>
goto failed;
}
the_thread->extensions = (void **) extensions_area;
ffc0c7e8: 93 1f 01 38 stw r24,312(r31)
ffc0c7ec: 7f 0b c3 78 mr r11,r24
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
ffc0c7f0: 38 00 00 00 li r0,0
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
goto failed;
}
the_thread->extensions = (void **) extensions_area;
ffc0c7f4: 81 1e 28 2c lwz r8,10284(r30)
ffc0c7f8: 39 20 00 00 li r9,0
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
the_thread->extensions[i] = NULL;
ffc0c7fc: 39 40 00 00 li r10,0
ffc0c800: 48 00 00 08 b ffc0c808 <_Thread_Initialize+0x214>
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
goto failed;
}
the_thread->extensions = (void **) extensions_area;
ffc0c804: 81 7f 01 38 lwz r11,312(r31)
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
ffc0c808: 39 29 00 01 addi r9,r9,1
ffc0c80c: 7f 89 40 40 cmplw cr7,r9,r8
the_thread->extensions[i] = NULL;
ffc0c810: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc0c814: 7d 4b 01 2e stwx r10,r11,r0
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
ffc0c818: 7d 20 4b 78 mr r0,r9
ffc0c81c: 40 9d ff e8 ble+ cr7,ffc0c804 <_Thread_Initialize+0x210>
ffc0c820: 4b ff fe 88 b ffc0c6a8 <_Thread_Initialize+0xb4>
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
#else
if ( !stack_area ) {
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
ffc0c824: 7c 83 23 78 mr r3,r4
ffc0c828: 90 c1 00 08 stw r6,8(r1)
ffc0c82c: 7c c4 33 78 mr r4,r6
ffc0c830: 90 e1 00 0c stw r7,12(r1)
ffc0c834: 48 00 08 89 bl ffc0d0bc <_Thread_Stack_Allocate>
if ( !actual_stack_size || actual_stack_size < stack_size )
ffc0c838: 7c 60 1b 79 mr. r0,r3
ffc0c83c: 80 c1 00 08 lwz r6,8(r1)
return false; /* stack allocation failed */
ffc0c840: 38 60 00 00 li r3,0
stack = the_thread->Start.stack;
#else
if ( !stack_area ) {
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
if ( !actual_stack_size || actual_stack_size < stack_size )
ffc0c844: 80 e1 00 0c lwz r7,12(r1)
ffc0c848: 41 a2 ff 3c beq- ffc0c784 <_Thread_Initialize+0x190>
ffc0c84c: 7f 86 00 40 cmplw cr7,r6,r0
return false; /* stack allocation failed */
ffc0c850: 7f c3 f3 78 mr r3,r30
stack = the_thread->Start.stack;
#else
if ( !stack_area ) {
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
if ( !actual_stack_size || actual_stack_size < stack_size )
ffc0c854: 41 bd ff 30 bgt- cr7,ffc0c784 <_Thread_Initialize+0x190><== NEVER TAKEN
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
the_thread->Start.core_allocated_stack = true;
ffc0c858: 39 20 00 01 li r9,1
if ( !stack_area ) {
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
if ( !actual_stack_size || actual_stack_size < stack_size )
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
ffc0c85c: 83 df 00 c4 lwz r30,196(r31)
the_thread->Start.core_allocated_stack = true;
ffc0c860: 99 3f 00 b4 stb r9,180(r31)
ffc0c864: 4b ff fd fc b ffc0c660 <_Thread_Initialize+0x6c>
size_t actual_stack_size = 0;
void *stack = NULL;
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
void *fp_area;
#endif
void *sched = NULL;
ffc0c868: 3b 60 00 00 li r27,0
ffc0c86c: 4b ff fe dc b ffc0c748 <_Thread_Initialize+0x154>
ffc0da84 <_Thread_Restart>:
bool _Thread_Restart(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
ffc0da84: 94 21 ff e8 stwu r1,-24(r1)
ffc0da88: 7c 08 02 a6 mflr r0
ffc0da8c: 90 01 00 1c stw r0,28(r1)
*/
RTEMS_INLINE_ROUTINE bool _States_Is_dormant (
States_Control the_states
)
{
return (the_states & STATES_DORMANT);
ffc0da90: 80 03 00 10 lwz r0,16(r3)
ffc0da94: 93 e1 00 14 stw r31,20(r1)
ffc0da98: 7c 7f 1b 78 mr r31,r3
if ( !_States_Is_dormant( the_thread->current_state ) ) {
ffc0da9c: 70 09 00 01 andi. r9,r0,1
bool _Thread_Restart(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
ffc0daa0: 93 c1 00 10 stw r30,16(r1)
_Thread_Restart_self();
return true;
}
return false;
ffc0daa4: 38 00 00 00 li r0,0
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
if ( !_States_Is_dormant( the_thread->current_state ) ) {
ffc0daa8: 41 82 00 20 beq- ffc0dac8 <_Thread_Restart+0x44>
return true;
}
return false;
}
ffc0daac: 7c 03 03 78 mr r3,r0
ffc0dab0: 80 01 00 1c lwz r0,28(r1)
ffc0dab4: 83 c1 00 10 lwz r30,16(r1)
ffc0dab8: 7c 08 03 a6 mtlr r0
ffc0dabc: 83 e1 00 14 lwz r31,20(r1)
ffc0dac0: 38 21 00 18 addi r1,r1,24
ffc0dac4: 4e 80 00 20 blr
Thread_Entry_numeric_type numeric_argument
)
{
if ( !_States_Is_dormant( the_thread->current_state ) ) {
_Thread_Set_transient( the_thread );
ffc0dac8: 90 81 00 08 stw r4,8(r1)
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
ffc0dacc: 3f c0 00 00 lis r30,0
ffc0dad0: 3b de 31 64 addi r30,r30,12644
ffc0dad4: 90 a1 00 0c stw r5,12(r1)
ffc0dad8: 48 00 01 05 bl ffc0dbdc <_Thread_Set_transient>
_Thread_Reset( the_thread, pointer_argument, numeric_argument );
ffc0dadc: 7f e3 fb 78 mr r3,r31
ffc0dae0: 80 81 00 08 lwz r4,8(r1)
ffc0dae4: 80 a1 00 0c lwz r5,12(r1)
ffc0dae8: 48 00 48 5d bl ffc12344 <_Thread_Reset>
_Thread_Load_environment( the_thread );
ffc0daec: 7f e3 fb 78 mr r3,r31
ffc0daf0: 48 00 44 c1 bl ffc11fb0 <_Thread_Load_environment>
_Thread_Ready( the_thread );
ffc0daf4: 7f e3 fb 78 mr r3,r31
ffc0daf8: 48 00 47 fd bl ffc122f4 <_Thread_Ready>
_User_extensions_Thread_restart( the_thread );
ffc0dafc: 7f e3 fb 78 mr r3,r31
ffc0db00: 48 00 07 75 bl ffc0e274 <_User_extensions_Thread_restart>
if ( _Thread_Is_executing ( the_thread ) )
ffc0db04: 81 3e 00 0c lwz r9,12(r30)
_Thread_Restart_self();
return true;
ffc0db08: 38 00 00 01 li r0,1
_Thread_Ready( the_thread );
_User_extensions_Thread_restart( the_thread );
if ( _Thread_Is_executing ( the_thread ) )
ffc0db0c: 7f 9f 48 00 cmpw cr7,r31,r9
ffc0db10: 40 9e ff 9c bne+ cr7,ffc0daac <_Thread_Restart+0x28>
*/
RTEMS_INLINE_ROUTINE void _Thread_Restart_self( void )
{
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( _Thread_Executing->fp_context != NULL )
ffc0db14: 80 1f 01 28 lwz r0,296(r31)
ffc0db18: 2f 80 00 00 cmpwi cr7,r0,0
ffc0db1c: 41 9e 00 0c beq- cr7,ffc0db28 <_Thread_Restart+0xa4> <== NEVER TAKEN
_Context_Restore_fp( &_Thread_Executing->fp_context );
ffc0db20: 38 7f 01 28 addi r3,r31,296
ffc0db24: 48 01 17 fd bl ffc1f320 <_CPU_Context_restore_fp>
#endif
_CPU_Context_Restart_self( &_Thread_Executing->Registers );
ffc0db28: 80 7e 00 0c lwz r3,12(r30)
ffc0db2c: 38 63 00 c8 addi r3,r3,200
ffc0db30: 48 01 19 b1 bl ffc1f4e0 <_CPU_Context_restore>
ffc0d164 <_Thread_Stack_Free>:
*/
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
ffc0d164: 7c 08 02 a6 mflr r0
ffc0d168: 94 21 ff f8 stwu r1,-8(r1)
ffc0d16c: 90 01 00 0c stw r0,12(r1)
#if defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API)
/*
* If the API provided the stack space, then don't free it.
*/
if ( !the_thread->Start.core_allocated_stack )
ffc0d170: 88 03 00 b4 lbz r0,180(r3)
ffc0d174: 2f 80 00 00 cmpwi cr7,r0,0
ffc0d178: 41 9e 00 20 beq- cr7,ffc0d198 <_Thread_Stack_Free+0x34> <== NEVER TAKEN
* Call ONLY the CPU table stack free hook, or the
* the RTEMS workspace free. This is so the free
* routine properly matches the allocation of the stack.
*/
if ( Configuration.stack_free_hook )
ffc0d17c: 3d 20 00 00 lis r9,0
(*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area );
ffc0d180: 80 63 00 bc lwz r3,188(r3)
* Call ONLY the CPU table stack free hook, or the
* the RTEMS workspace free. This is so the free
* routine properly matches the allocation of the stack.
*/
if ( Configuration.stack_free_hook )
ffc0d184: 80 09 20 28 lwz r0,8232(r9)
ffc0d188: 2f 80 00 00 cmpwi cr7,r0,0
ffc0d18c: 41 9e 00 1c beq- cr7,ffc0d1a8 <_Thread_Stack_Free+0x44>
(*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area );
ffc0d190: 7c 09 03 a6 mtctr r0
ffc0d194: 4e 80 04 21 bctrl
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
}
ffc0d198: 80 01 00 0c lwz r0,12(r1)
ffc0d19c: 38 21 00 08 addi r1,r1,8
ffc0d1a0: 7c 08 03 a6 mtlr r0
ffc0d1a4: 4e 80 00 20 blr
*/
if ( Configuration.stack_free_hook )
(*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area );
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
ffc0d1a8: 48 00 0a 7d bl ffc0dc24 <_Workspace_Free>
}
ffc0d1ac: 80 01 00 0c lwz r0,12(r1)
ffc0d1b0: 38 21 00 08 addi r1,r1,8
ffc0d1b4: 7c 08 03 a6 mtlr r0
ffc0d1b8: 4e 80 00 20 blr
ffc11688 <_Thread_queue_Process_timeout>:
#include <rtems/score/tqdata.h>
void _Thread_queue_Process_timeout(
Thread_Control *the_thread
)
{
ffc11688: 7c 08 02 a6 mflr r0
ffc1168c: 94 21 ff f8 stwu r1,-8(r1)
ffc11690: 7c 64 1b 78 mr r4,r3
ffc11694: 90 01 00 0c stw r0,12(r1)
Thread_queue_Control *the_thread_queue = the_thread->Wait.queue;
ffc11698: 80 63 00 44 lwz r3,68(r3)
* 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 &&
ffc1169c: 80 03 00 30 lwz r0,48(r3)
ffc116a0: 2f 80 00 00 cmpwi cr7,r0,0
ffc116a4: 41 9e 00 14 beq- cr7,ffc116b8 <_Thread_queue_Process_timeout+0x30>
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
ffc116a8: 3d 20 00 00 lis r9,0
ffc116ac: 81 29 31 50 lwz r9,12624(r9)
ffc116b0: 7f 84 48 00 cmpw cr7,r4,r9
ffc116b4: 41 9e 00 20 beq- cr7,ffc116d4 <_Thread_queue_Process_timeout+0x4c><== ALWAYS TAKEN
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
}
} else {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
ffc116b8: 80 03 00 3c lwz r0,60(r3)
ffc116bc: 90 04 00 34 stw r0,52(r4)
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
ffc116c0: 4b ff fe 85 bl ffc11544 <_Thread_queue_Extract>
}
}
ffc116c4: 80 01 00 0c lwz r0,12(r1)
ffc116c8: 38 21 00 08 addi r1,r1,8
ffc116cc: 7c 08 03 a6 mtlr r0
ffc116d0: 4e 80 00 20 blr
* a timeout is not allowed to occur.
*/
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED &&
_Thread_Is_executing( the_thread ) ) {
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
ffc116d4: 2f 80 00 03 cmpwi cr7,r0,3
ffc116d8: 41 be ff ec beq- cr7,ffc116c4 <_Thread_queue_Process_timeout+0x3c>
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
ffc116dc: 80 03 00 3c lwz r0,60(r3)
ffc116e0: 90 04 00 34 stw r0,52(r4)
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
ffc116e4: 38 00 00 02 li r0,2
ffc116e8: 90 03 00 30 stw r0,48(r3)
ffc116ec: 4b ff ff d8 b ffc116c4 <_Thread_queue_Process_timeout+0x3c>
ffc0cebc <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
ffc0cebc: 94 21 ff d8 stwu r1,-40(r1)
ffc0cec0: 7c 08 02 a6 mflr r0
ffc0cec4: 93 e1 00 24 stw r31,36(r1)
/*
* Just in case the thread really wasn't blocked on a thread queue
* when we get here.
*/
if ( !the_thread_queue )
ffc0cec8: 7c 7f 1b 79 mr. r31,r3
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
ffc0cecc: 93 c1 00 20 stw r30,32(r1)
ffc0ced0: 7c 9e 23 78 mr r30,r4
ffc0ced4: 90 01 00 2c stw r0,44(r1)
ffc0ced8: 93 a1 00 1c stw r29,28(r1)
/*
* Just in case the thread really wasn't blocked on a thread queue
* when we get here.
*/
if ( !the_thread_queue )
ffc0cedc: 41 82 00 10 beq- ffc0ceec <_Thread_queue_Requeue+0x30> <== 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 ) {
ffc0cee0: 80 1f 00 34 lwz r0,52(r31)
ffc0cee4: 2f 80 00 01 cmpwi cr7,r0,1
ffc0cee8: 41 9e 00 20 beq- cr7,ffc0cf08 <_Thread_queue_Requeue+0x4c><== ALWAYS TAKEN
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
}
_ISR_Enable( level );
}
}
ffc0ceec: 80 01 00 2c lwz r0,44(r1) <== NOT EXECUTED
ffc0cef0: 83 a1 00 1c lwz r29,28(r1) <== NOT EXECUTED
ffc0cef4: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc0cef8: 83 c1 00 20 lwz r30,32(r1) <== NOT EXECUTED
ffc0cefc: 83 e1 00 24 lwz r31,36(r1) <== NOT EXECUTED
ffc0cf00: 38 21 00 28 addi r1,r1,40 <== NOT EXECUTED
ffc0cf04: 4e 80 00 20 blr <== NOT EXECUTED
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0cf08: 7f a0 00 a6 mfmsr r29
ffc0cf0c: 7d 30 42 a6 mfsprg r9,0
ffc0cf10: 7f a9 48 78 andc r9,r29,r9
ffc0cf14: 7d 20 01 24 mtmsr r9
ffc0cf18: 3d 60 00 03 lis r11,3
ffc0cf1c: 81 24 00 10 lwz r9,16(r4)
ffc0cf20: 61 6b be e0 ori r11,r11,48864
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
ffc0cf24: 7d 6a 48 39 and. r10,r11,r9
ffc0cf28: 40 82 00 24 bne- ffc0cf4c <_Thread_queue_Requeue+0x90> <== ALWAYS TAKEN
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0cf2c: 7f a0 01 24 mtmsr r29 <== NOT EXECUTED
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
}
_ISR_Enable( level );
}
}
ffc0cf30: 80 01 00 2c lwz r0,44(r1)
ffc0cf34: 83 a1 00 1c lwz r29,28(r1)
ffc0cf38: 7c 08 03 a6 mtlr r0
ffc0cf3c: 83 c1 00 20 lwz r30,32(r1)
ffc0cf40: 83 e1 00 24 lwz r31,36(r1)
ffc0cf44: 38 21 00 28 addi r1,r1,40
ffc0cf48: 4e 80 00 20 blr
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;
ffc0cf4c: 90 1f 00 30 stw r0,48(r31)
ISR_Level level_ignored;
_ISR_Disable( level );
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
ffc0cf50: 38 a0 00 01 li r5,1
ffc0cf54: 48 00 46 35 bl ffc11588 <_Thread_queue_Extract_priority_helper>
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
ffc0cf58: 7f e3 fb 78 mr r3,r31
ffc0cf5c: 7f c4 f3 78 mr r4,r30
ffc0cf60: 38 a1 00 08 addi r5,r1,8
ffc0cf64: 4b ff fc 81 bl ffc0cbe4 <_Thread_queue_Enqueue_priority>
ffc0cf68: 7f a0 01 24 mtmsr r29
ffc0cf6c: 4b ff ff c4 b ffc0cf30 <_Thread_queue_Requeue+0x74>
ffc0cf70 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
ffc0cf70: 94 21 ff e8 stwu r1,-24(r1)
ffc0cf74: 7c 08 02 a6 mflr r0
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
ffc0cf78: 38 81 00 08 addi r4,r1,8
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
ffc0cf7c: 90 01 00 1c stw r0,28(r1)
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
ffc0cf80: 4b ff f5 a5 bl ffc0c524 <_Thread_Get>
switch ( location ) {
ffc0cf84: 80 01 00 08 lwz r0,8(r1)
ffc0cf88: 2f 80 00 00 cmpwi cr7,r0,0
ffc0cf8c: 40 9e 00 1c bne- cr7,ffc0cfa8 <_Thread_queue_Timeout+0x38><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
ffc0cf90: 48 00 46 f9 bl ffc11688 <_Thread_queue_Process_timeout>
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
ffc0cf94: 3d 20 00 00 lis r9,0
ffc0cf98: 81 69 28 0c lwz r11,10252(r9)
ffc0cf9c: 38 0b ff ff addi r0,r11,-1
ffc0cfa0: 90 09 28 0c stw r0,10252(r9)
return _Thread_Dispatch_disable_level;
ffc0cfa4: 80 09 28 0c lwz r0,10252(r9)
_Thread_Unnest_dispatch();
break;
}
}
ffc0cfa8: 80 01 00 1c lwz r0,28(r1)
ffc0cfac: 38 21 00 18 addi r1,r1,24
ffc0cfb0: 7c 08 03 a6 mtlr r0
ffc0cfb4: 4e 80 00 20 blr
ffc1c4a8 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
ffc1c4a8: 94 21 ff 98 stwu r1,-104(r1)
ffc1c4ac: 7c 08 02 a6 mflr r0
ffc1c4b0: 92 a1 00 3c stw r21,60(r1)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc1c4b4: 3a a1 00 14 addi r21,r1,20
ffc1c4b8: 90 01 00 6c stw r0,108(r1)
head->previous = NULL;
ffc1c4bc: 38 00 00 00 li r0,0
ffc1c4c0: 92 e1 00 44 stw r23,68(r1)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc1c4c4: 3a e1 00 0c addi r23,r1,12
ffc1c4c8: 93 41 00 50 stw r26,80(r1)
ffc1c4cc: 3b 41 00 18 addi r26,r1,24
ffc1c4d0: 93 81 00 58 stw r28,88(r1)
head->previous = NULL;
tail->previous = head;
ffc1c4d4: 3b 81 00 08 addi r28,r1,8
ffc1c4d8: 92 81 00 38 stw r20,56(r1)
ffc1c4dc: 3e 80 00 00 lis r20,0
ffc1c4e0: 3a 94 28 e0 addi r20,r20,10464
ffc1c4e4: 93 01 00 48 stw r24,72(r1)
ffc1c4e8: 3f 00 00 00 lis r24,0
ffc1c4ec: 3b 18 29 14 addi r24,r24,10516
ffc1c4f0: 93 21 00 4c stw r25,76(r1)
ffc1c4f4: 3f 20 00 00 lis r25,0
ffc1c4f8: 3b 39 28 f8 addi r25,r25,10488
ffc1c4fc: 93 c1 00 60 stw r30,96(r1)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc1c500: 93 41 00 14 stw r26,20(r1)
head->previous = NULL;
ffc1c504: 90 01 00 18 stw r0,24(r1)
tail->previous = head;
ffc1c508: 92 a1 00 1c stw r21,28(r1)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc1c50c: 92 e1 00 08 stw r23,8(r1)
head->previous = NULL;
ffc1c510: 90 01 00 0c stw r0,12(r1)
tail->previous = head;
ffc1c514: 93 81 00 10 stw r28,16(r1)
ffc1c518: 92 01 00 28 stw r16,40(r1)
ffc1c51c: 3a 03 00 08 addi r16,r3,8
ffc1c520: 92 21 00 2c stw r17,44(r1)
ffc1c524: 3a 23 00 40 addi r17,r3,64
ffc1c528: 92 41 00 30 stw r18,48(r1)
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
ffc1c52c: 3a 40 00 00 li r18,0
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
ffc1c530: 92 61 00 34 stw r19,52(r1)
_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;
ffc1c534: 3a 60 00 01 li r19,1
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
ffc1c538: 92 c1 00 40 stw r22,64(r1)
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
ffc1c53c: 3a c0 00 00 li r22,0
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
ffc1c540: 93 61 00 54 stw r27,84(r1)
ffc1c544: 3b 63 00 68 addi r27,r3,104
ffc1c548: 93 a1 00 5c stw r29,92(r1)
ffc1c54c: 3b a3 00 30 addi r29,r3,48
ffc1c550: 93 e1 00 64 stw r31,100(r1)
ffc1c554: 7c 7f 1b 78 mr r31,r3
{
/*
* 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;
ffc1c558: 92 bf 00 78 stw r21,120(r31)
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
ffc1c55c: 7f 85 e3 78 mr r5,r28
ffc1c560: 7f a3 eb 78 mr r3,r29
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
ffc1c564: 80 18 00 00 lwz r0,0(r24)
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
ffc1c568: 80 9f 00 3c lwz r4,60(r31)
watchdogs->last_snapshot = snapshot;
ffc1c56c: 90 1f 00 3c stw r0,60(r31)
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
ffc1c570: 7c 84 00 50 subf r4,r4,r0
ffc1c574: 48 00 5a 0d bl ffc21f80 <_Watchdog_Adjust_to_chain>
static void _Timer_server_Process_tod_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
ffc1c578: 83 d9 00 00 lwz r30,0(r25)
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
ffc1c57c: 80 bf 00 74 lwz r5,116(r31)
/*
* 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 ) {
ffc1c580: 7f 9e 28 40 cmplw cr7,r30,r5
ffc1c584: 41 9d 00 98 bgt- cr7,ffc1c61c <_Timer_server_Body+0x174>
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
} else if ( snapshot < last_snapshot ) {
ffc1c588: 41 9c 00 a8 blt- cr7,ffc1c630 <_Timer_server_Body+0x188>
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
}
watchdogs->last_snapshot = snapshot;
ffc1c58c: 93 df 00 74 stw r30,116(r31)
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
ffc1c590: 80 7f 00 78 lwz r3,120(r31)
ffc1c594: 48 00 0e 91 bl ffc1d424 <_Chain_Get>
if ( timer == NULL ) {
ffc1c598: 7c 64 1b 79 mr. r4,r3
ffc1c59c: 41 82 00 34 beq- ffc1c5d0 <_Timer_server_Body+0x128> <== ALWAYS TAKEN
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
ffc1c5a0: 80 04 00 38 lwz r0,56(r4) <== NOT EXECUTED
ffc1c5a4: 2f 80 00 01 cmpwi cr7,r0,1 <== NOT EXECUTED
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
ffc1c5a8: 2f 00 00 03 cmpwi cr6,r0,3 <== NOT EXECUTED
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
ffc1c5ac: 41 9e 00 98 beq- cr7,ffc1c644 <_Timer_server_Body+0x19c><== NOT EXECUTED
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
ffc1c5b0: 40 9a ff e0 bne+ cr6,ffc1c590 <_Timer_server_Body+0xe8> <== NOT EXECUTED
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
ffc1c5b4: 38 84 00 10 addi r4,r4,16 <== NOT EXECUTED
ffc1c5b8: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc1c5bc: 48 00 5a 7d bl ffc22038 <_Watchdog_Insert> <== NOT EXECUTED
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
ffc1c5c0: 80 7f 00 78 lwz r3,120(r31) <== NOT EXECUTED
ffc1c5c4: 48 00 0e 61 bl ffc1d424 <_Chain_Get> <== NOT EXECUTED
if ( timer == NULL ) {
ffc1c5c8: 7c 64 1b 79 mr. r4,r3 <== NOT EXECUTED
ffc1c5cc: 40 82 ff d4 bne+ ffc1c5a0 <_Timer_server_Body+0xf8> <== NOT EXECUTED
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc1c5d0: 7d 20 00 a6 mfmsr r9
ffc1c5d4: 7c 10 42 a6 mfsprg r0,0
ffc1c5d8: 7d 20 00 78 andc r0,r9,r0
ffc1c5dc: 7c 00 01 24 mtmsr r0
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
if ( _Chain_Is_empty( insert_chain ) ) {
ffc1c5e0: 80 01 00 14 lwz r0,20(r1)
ffc1c5e4: 7f 80 d0 00 cmpw cr7,r0,r26
ffc1c5e8: 41 9e 00 6c beq- cr7,ffc1c654 <_Timer_server_Body+0x1ac><== ALWAYS TAKEN
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc1c5ec: 7d 20 01 24 mtmsr r9 <== NOT EXECUTED
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
ffc1c5f0: 80 18 00 00 lwz r0,0(r24) <== NOT EXECUTED
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
ffc1c5f4: 7f 85 e3 78 mr r5,r28 <== NOT EXECUTED
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
ffc1c5f8: 80 9f 00 3c lwz r4,60(r31) <== NOT EXECUTED
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
ffc1c5fc: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
ffc1c600: 90 1f 00 3c stw r0,60(r31) <== NOT EXECUTED
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
ffc1c604: 7c 84 00 50 subf r4,r4,r0 <== NOT EXECUTED
ffc1c608: 48 00 59 79 bl ffc21f80 <_Watchdog_Adjust_to_chain> <== NOT EXECUTED
static void _Timer_server_Process_tod_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
ffc1c60c: 83 d9 00 00 lwz r30,0(r25) <== NOT EXECUTED
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
ffc1c610: 80 bf 00 74 lwz r5,116(r31) <== NOT EXECUTED
/*
* 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 ) {
ffc1c614: 7f 9e 28 40 cmplw cr7,r30,r5 <== NOT EXECUTED
ffc1c618: 40 9d ff 70 ble+ cr7,ffc1c588 <_Timer_server_Body+0xe0> <== NOT EXECUTED
/*
* 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 );
ffc1c61c: 7c 85 f0 50 subf r4,r5,r30
ffc1c620: 7f 63 db 78 mr r3,r27
ffc1c624: 7f 85 e3 78 mr r5,r28
ffc1c628: 48 00 59 59 bl ffc21f80 <_Watchdog_Adjust_to_chain>
ffc1c62c: 4b ff ff 60 b ffc1c58c <_Timer_server_Body+0xe4>
/*
* 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 );
ffc1c630: 7f 63 db 78 mr r3,r27
ffc1c634: 38 80 00 01 li r4,1
ffc1c638: 7c be 28 50 subf r5,r30,r5
ffc1c63c: 48 00 58 29 bl ffc21e64 <_Watchdog_Adjust>
ffc1c640: 4b ff ff 4c b ffc1c58c <_Timer_server_Body+0xe4>
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
ffc1c644: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc1c648: 38 84 00 10 addi r4,r4,16 <== NOT EXECUTED
ffc1c64c: 48 00 59 ed bl ffc22038 <_Watchdog_Insert> <== NOT EXECUTED
ffc1c650: 4b ff ff 40 b ffc1c590 <_Timer_server_Body+0xe8> <== NOT EXECUTED
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
if ( _Chain_Is_empty( insert_chain ) ) {
ts->insert_chain = NULL;
ffc1c654: 90 9f 00 78 stw r4,120(r31)
ffc1c658: 7d 20 01 24 mtmsr r9
_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 ) ) {
ffc1c65c: 80 01 00 08 lwz r0,8(r1)
ffc1c660: 7f 80 b8 00 cmpw cr7,r0,r23
ffc1c664: 40 be 00 30 bne+ cr7,ffc1c694 <_Timer_server_Body+0x1ec>
ffc1c668: 48 00 00 50 b ffc1c6b8 <_Timer_server_Body+0x210>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
ffc1c66c: 81 69 00 00 lwz r11,0(r9)
head->next = new_first;
new_first->previous = head;
ffc1c670: 93 8b 00 04 stw r28,4(r11)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
head->next = new_first;
ffc1c674: 91 61 00 08 stw r11,8(r1)
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
ffc1c678: 92 c9 00 08 stw r22,8(r9)
ffc1c67c: 7c 00 01 24 mtmsr r0
/*
* 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 );
ffc1c680: 80 09 00 1c lwz r0,28(r9)
ffc1c684: 80 69 00 20 lwz r3,32(r9)
ffc1c688: 80 89 00 24 lwz r4,36(r9)
ffc1c68c: 7c 09 03 a6 mtctr r0
ffc1c690: 4e 80 04 21 bctrl
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc1c694: 7c 00 00 a6 mfmsr r0
ffc1c698: 7d 30 42 a6 mfsprg r9,0
ffc1c69c: 7c 09 48 78 andc r9,r0,r9
ffc1c6a0: 7d 20 01 24 mtmsr r9
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
ffc1c6a4: 81 21 00 08 lwz r9,8(r1)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
ffc1c6a8: 7f 89 b8 00 cmpw cr7,r9,r23
ffc1c6ac: 40 9e ff c0 bne+ cr7,ffc1c66c <_Timer_server_Body+0x1c4>
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc1c6b0: 7c 00 01 24 mtmsr r0
ffc1c6b4: 4b ff fe a4 b ffc1c558 <_Timer_server_Body+0xb0>
}
} else {
ts->active = false;
ffc1c6b8: 9a 5f 00 7c stb r18,124(r31)
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc1c6bc: 80 14 00 00 lwz r0,0(r20)
ffc1c6c0: 30 00 00 01 addic r0,r0,1
ffc1c6c4: 90 14 00 00 stw r0,0(r20)
return _Thread_Dispatch_disable_level;
ffc1c6c8: 80 14 00 00 lwz r0,0(r20)
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
ffc1c6cc: 80 7f 00 00 lwz r3,0(r31)
ffc1c6d0: 38 80 00 08 li r4,8
ffc1c6d4: 48 00 4e 7d bl ffc21550 <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
ffc1c6d8: 7f e3 fb 78 mr r3,r31
ffc1c6dc: 4b ff fc a5 bl ffc1c380 <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
ffc1c6e0: 7f e3 fb 78 mr r3,r31
ffc1c6e4: 4b ff fd 31 bl ffc1c414 <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
ffc1c6e8: 48 00 42 b9 bl ffc209a0 <_Thread_Enable_dispatch>
ts->active = true;
ffc1c6ec: 9a 7f 00 7c stb r19,124(r31)
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
ffc1c6f0: 7e 03 83 78 mr r3,r16
ffc1c6f4: 48 00 5b 0d bl ffc22200 <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
ffc1c6f8: 7e 23 8b 78 mr r3,r17
ffc1c6fc: 48 00 5b 05 bl ffc22200 <_Watchdog_Remove>
ffc1c700: 4b ff fe 58 b ffc1c558 <_Timer_server_Body+0xb0>
ffc1c704 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
ffc1c704: 94 21 ff f0 stwu r1,-16(r1)
ffc1c708: 7c 08 02 a6 mflr r0
ffc1c70c: 7c 89 23 78 mr r9,r4
ffc1c710: 90 01 00 14 stw r0,20(r1)
if ( ts->insert_chain == NULL ) {
ffc1c714: 80 03 00 78 lwz r0,120(r3)
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
ffc1c718: 93 e1 00 0c stw r31,12(r1)
ffc1c71c: 7c 7f 1b 78 mr r31,r3
if ( ts->insert_chain == NULL ) {
ffc1c720: 2f 80 00 00 cmpwi cr7,r0,0
ffc1c724: 41 9e 00 20 beq- cr7,ffc1c744 <_Timer_server_Schedule_operation_method+0x40><== ALWAYS TAKEN
* 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 );
ffc1c728: 80 63 00 78 lwz r3,120(r3) <== NOT EXECUTED
ffc1c72c: 48 00 0c a1 bl ffc1d3cc <_Chain_Append> <== NOT EXECUTED
}
}
ffc1c730: 80 01 00 14 lwz r0,20(r1) <== NOT EXECUTED
ffc1c734: 83 e1 00 0c lwz r31,12(r1) <== NOT EXECUTED
ffc1c738: 38 21 00 10 addi r1,r1,16 <== NOT EXECUTED
ffc1c73c: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc1c740: 4e 80 00 20 blr <== NOT EXECUTED
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc1c744: 3d 60 00 00 lis r11,0
ffc1c748: 81 4b 28 e0 lwz r10,10464(r11)
ffc1c74c: 38 0a 00 01 addi r0,r10,1
ffc1c750: 90 0b 28 e0 stw r0,10464(r11)
return _Thread_Dispatch_disable_level;
ffc1c754: 80 0b 28 e0 lwz r0,10464(r11)
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
ffc1c758: 80 04 00 38 lwz r0,56(r4)
ffc1c75c: 2f 80 00 01 cmpwi cr7,r0,1
ffc1c760: 41 9e 00 ac beq- cr7,ffc1c80c <_Timer_server_Schedule_operation_method+0x108>
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
if ( !ts->active ) {
_Timer_server_Reset_interval_system_watchdog( ts );
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
ffc1c764: 2f 80 00 03 cmpwi cr7,r0,3
ffc1c768: 41 9e 00 1c beq- cr7,ffc1c784 <_Timer_server_Schedule_operation_method+0x80>
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
ffc1c76c: 48 00 42 35 bl ffc209a0 <_Thread_Enable_dispatch>
* 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 );
}
}
ffc1c770: 80 01 00 14 lwz r0,20(r1)
ffc1c774: 83 e1 00 0c lwz r31,12(r1)
ffc1c778: 38 21 00 10 addi r1,r1,16
ffc1c77c: 7c 08 03 a6 mtlr r0
ffc1c780: 4e 80 00 20 blr
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc1c784: 7c c0 00 a6 mfmsr r6
ffc1c788: 7c 10 42 a6 mfsprg r0,0
ffc1c78c: 7c c0 00 78 andc r0,r6,r0
ffc1c790: 7c 00 01 24 mtmsr r0
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
ffc1c794: 81 63 00 68 lwz r11,104(r3)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
ffc1c798: 38 03 00 6c addi r0,r3,108
/*
* 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();
ffc1c79c: 3d 40 00 00 lis r10,0
last_snapshot = ts->TOD_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
ffc1c7a0: 7f 8b 00 00 cmpw cr7,r11,r0
/*
* 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();
ffc1c7a4: 80 0a 28 f8 lwz r0,10488(r10)
last_snapshot = ts->TOD_watchdogs.last_snapshot;
ffc1c7a8: 81 43 00 74 lwz r10,116(r3)
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
ffc1c7ac: 41 9e 00 30 beq- cr7,ffc1c7dc <_Timer_server_Schedule_operation_method+0xd8>
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
if ( snapshot > last_snapshot ) {
ffc1c7b0: 7f 80 50 40 cmplw cr7,r0,r10
_ISR_Disable( level );
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;
ffc1c7b4: 80 eb 00 10 lwz r7,16(r11)
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
ffc1c7b8: 7d 07 52 14 add r8,r7,r10
delta_interval += delta;
ffc1c7bc: 7d 00 40 50 subf r8,r0,r8
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 ) {
ffc1c7c0: 40 9d 00 18 ble- cr7,ffc1c7d8 <_Timer_server_Schedule_operation_method+0xd4>
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
ffc1c7c4: 7d 4a 00 50 subf r10,r10,r0
if (delta_interval > delta) {
ffc1c7c8: 7f 87 50 40 cmplw cr7,r7,r10
delta_interval -= delta;
} else {
delta_interval = 0;
ffc1c7cc: 39 00 00 00 li r8,0
if ( snapshot > last_snapshot ) {
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
if (delta_interval > delta) {
ffc1c7d0: 40 9d 00 08 ble- cr7,ffc1c7d8 <_Timer_server_Schedule_operation_method+0xd4><== NEVER TAKEN
delta_interval -= delta;
ffc1c7d4: 7d 0a 38 50 subf r8,r10,r7
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
delta_interval += delta;
}
first_watchdog->delta_interval = delta_interval;
ffc1c7d8: 91 0b 00 10 stw r8,16(r11)
}
ts->TOD_watchdogs.last_snapshot = snapshot;
ffc1c7dc: 90 1f 00 74 stw r0,116(r31)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc1c7e0: 7c c0 01 24 mtmsr r6
_ISR_Enable( level );
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
ffc1c7e4: 38 7f 00 68 addi r3,r31,104
ffc1c7e8: 38 89 00 10 addi r4,r9,16
ffc1c7ec: 48 00 58 4d bl ffc22038 <_Watchdog_Insert>
if ( !ts->active ) {
ffc1c7f0: 88 1f 00 7c lbz r0,124(r31)
ffc1c7f4: 2f 80 00 00 cmpwi cr7,r0,0
ffc1c7f8: 40 9e ff 74 bne+ cr7,ffc1c76c <_Timer_server_Schedule_operation_method+0x68>
_Timer_server_Reset_tod_system_watchdog( ts );
ffc1c7fc: 7f e3 fb 78 mr r3,r31
ffc1c800: 4b ff fc 15 bl ffc1c414 <_Timer_server_Reset_tod_system_watchdog>
}
}
_Thread_Enable_dispatch();
ffc1c804: 48 00 41 9d bl ffc209a0 <_Thread_Enable_dispatch>
ffc1c808: 4b ff ff 68 b ffc1c770 <_Timer_server_Schedule_operation_method+0x6c>
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc1c80c: 7c c0 00 a6 mfmsr r6
ffc1c810: 7c 10 42 a6 mfsprg r0,0
ffc1c814: 7c c0 00 78 andc r0,r6,r0
ffc1c818: 7c 00 01 24 mtmsr r0
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
ffc1c81c: 81 63 00 30 lwz r11,48(r3)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
ffc1c820: 38 03 00 34 addi r0,r3,52
/*
* 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;
ffc1c824: 3d 40 00 00 lis r10,0
last_snapshot = ts->Interval_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
ffc1c828: 7f 8b 00 00 cmpw cr7,r11,r0
/*
* 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;
ffc1c82c: 80 0a 29 14 lwz r0,10516(r10)
last_snapshot = ts->Interval_watchdogs.last_snapshot;
ffc1c830: 81 03 00 3c lwz r8,60(r3)
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
ffc1c834: 41 9e 00 20 beq- cr7,ffc1c854 <_Timer_server_Schedule_operation_method+0x150>
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
delta_interval = first_watchdog->delta_interval;
ffc1c838: 80 eb 00 10 lwz r7,16(r11)
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
ffc1c83c: 7d 08 00 50 subf r8,r8,r0
delta_interval = first_watchdog->delta_interval;
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
ffc1c840: 39 40 00 00 li r10,0
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
delta_interval = first_watchdog->delta_interval;
if (delta_interval > delta) {
ffc1c844: 7f 88 38 40 cmplw cr7,r8,r7
ffc1c848: 40 9c 00 08 bge- cr7,ffc1c850 <_Timer_server_Schedule_operation_method+0x14c>
delta_interval -= delta;
ffc1c84c: 7d 48 38 50 subf r10,r8,r7
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
ffc1c850: 91 4b 00 10 stw r10,16(r11)
}
ts->Interval_watchdogs.last_snapshot = snapshot;
ffc1c854: 90 1f 00 3c stw r0,60(r31)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc1c858: 7c c0 01 24 mtmsr r6
_ISR_Enable( level );
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
ffc1c85c: 38 7f 00 30 addi r3,r31,48
ffc1c860: 38 89 00 10 addi r4,r9,16
ffc1c864: 48 00 57 d5 bl ffc22038 <_Watchdog_Insert>
if ( !ts->active ) {
ffc1c868: 88 1f 00 7c lbz r0,124(r31)
ffc1c86c: 2f 80 00 00 cmpwi cr7,r0,0
ffc1c870: 40 9e fe fc bne+ cr7,ffc1c76c <_Timer_server_Schedule_operation_method+0x68>
_Timer_server_Reset_interval_system_watchdog( ts );
ffc1c874: 7f e3 fb 78 mr r3,r31
ffc1c878: 4b ff fb 09 bl ffc1c380 <_Timer_server_Reset_interval_system_watchdog>
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
ffc1c87c: 48 00 41 25 bl ffc209a0 <_Thread_Enable_dispatch>
ffc1c880: 4b ff fe f0 b ffc1c770 <_Timer_server_Schedule_operation_method+0x6c>
ffc0d528 <_User_extensions_Fatal>:
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
ffc0d528: 94 21 ff e0 stwu r1,-32(r1)
ffc0d52c: 7c 08 02 a6 mflr r0
ffc0d530: 93 c1 00 18 stw r30,24(r1)
ffc0d534: 3f c0 00 00 lis r30,0
ffc0d538: 3b de 2d f4 addi r30,r30,11764
ffc0d53c: 93 e1 00 1c stw r31,28(r1)
ffc0d540: 83 fe 00 08 lwz r31,8(r30)
ffc0d544: 93 61 00 0c stw r27,12(r1)
ffc0d548: 7c 7b 1b 78 mr r27,r3
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
ffc0d54c: 7f 9f f0 00 cmpw cr7,r31,r30
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
ffc0d550: 93 81 00 10 stw r28,16(r1)
ffc0d554: 7c 9c 23 78 mr r28,r4
ffc0d558: 93 a1 00 14 stw r29,20(r1)
ffc0d55c: 7c bd 2b 78 mr r29,r5
ffc0d560: 90 01 00 24 stw r0,36(r1)
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
ffc0d564: 41 9e 00 30 beq- cr7,ffc0d594 <_User_extensions_Fatal+0x6c><== NEVER TAKEN
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
ffc0d568: 80 1f 00 30 lwz r0,48(r31)
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
ffc0d56c: 7f 63 db 78 mr r3,r27
ffc0d570: 7f 84 e3 78 mr r4,r28
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
ffc0d574: 2f 80 00 00 cmpwi cr7,r0,0
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
ffc0d578: 7f a5 eb 78 mr r5,r29
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
ffc0d57c: 41 9e 00 0c beq- cr7,ffc0d588 <_User_extensions_Fatal+0x60>
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
ffc0d580: 7c 09 03 a6 mtctr r0
ffc0d584: 4e 80 04 21 bctrl
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
ffc0d588: 83 ff 00 04 lwz r31,4(r31)
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
ffc0d58c: 7f 9f f0 00 cmpw cr7,r31,r30
ffc0d590: 40 9e ff d8 bne+ cr7,ffc0d568 <_User_extensions_Fatal+0x40>
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
ffc0d594: 80 01 00 24 lwz r0,36(r1)
ffc0d598: 83 61 00 0c lwz r27,12(r1)
ffc0d59c: 7c 08 03 a6 mtlr r0
ffc0d5a0: 83 81 00 10 lwz r28,16(r1)
ffc0d5a4: 83 a1 00 14 lwz r29,20(r1)
ffc0d5a8: 83 c1 00 18 lwz r30,24(r1)
ffc0d5ac: 83 e1 00 1c lwz r31,28(r1)
ffc0d5b0: 38 21 00 20 addi r1,r1,32
ffc0d5b4: 4e 80 00 20 blr
ffc0d338 <_User_extensions_Handler_initialization>:
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
ffc0d338: 94 21 ff e8 stwu r1,-24(r1)
ffc0d33c: 7c 08 02 a6 mflr r0
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;
ffc0d340: 3c e0 00 00 lis r7,0
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
ffc0d344: 90 01 00 1c stw r0,28(r1)
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;
ffc0d348: 38 e7 20 04 addi r7,r7,8196
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc0d34c: 3d 00 00 00 lis r8,0
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
ffc0d350: 93 a1 00 0c stw r29,12(r1)
ffc0d354: 3d 40 00 00 lis r10,0
ffc0d358: 39 68 2d f4 addi r11,r8,11764
uint32_t i;
uint32_t number_of_extensions;
User_extensions_Table *initial_extensions;
number_of_extensions = Configuration.number_of_initial_extensions;
initial_extensions = Configuration.User_extension_table;
ffc0d35c: 83 a7 00 3c lwz r29,60(r7)
ffc0d360: 39 2a 2c d0 addi r9,r10,11472
head->previous = NULL;
ffc0d364: 38 00 00 00 li r0,0
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
ffc0d368: 93 c1 00 10 stw r30,16(r1)
initial_extensions = Configuration.User_extension_table;
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
ffc0d36c: 2f 9d 00 00 cmpwi cr7,r29,0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc0d370: 38 ab 00 04 addi r5,r11,4
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
ffc0d374: 93 81 00 08 stw r28,8(r1)
ffc0d378: 38 c9 00 04 addi r6,r9,4
ffc0d37c: 93 e1 00 14 stw r31,20(r1)
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;
ffc0d380: 83 c7 00 38 lwz r30,56(r7)
ffc0d384: 90 a8 2d f4 stw r5,11764(r8)
head->previous = NULL;
ffc0d388: 90 0b 00 04 stw r0,4(r11)
tail->previous = head;
ffc0d38c: 91 6b 00 08 stw r11,8(r11)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc0d390: 90 ca 2c d0 stw r6,11472(r10)
head->previous = NULL;
ffc0d394: 90 09 00 04 stw r0,4(r9)
tail->previous = head;
ffc0d398: 91 29 00 08 stw r9,8(r9)
initial_extensions = Configuration.User_extension_table;
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
ffc0d39c: 41 9e 00 88 beq- cr7,ffc0d424 <_User_extensions_Handler_initialization+0xec><== NEVER TAKEN
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
ffc0d3a0: 1f 9e 00 34 mulli r28,r30,52
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
extension = (User_extensions_Control *)
ffc0d3a4: 7f 83 e3 78 mr r3,r28
ffc0d3a8: 48 00 08 a9 bl ffc0dc50 <_Workspace_Allocate_or_fatal_error>
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
ffc0d3ac: 38 80 00 00 li r4,0
ffc0d3b0: 7f 85 e3 78 mr r5,r28
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
extension = (User_extensions_Control *)
ffc0d3b4: 7c 7f 1b 78 mr r31,r3
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
ffc0d3b8: 48 00 77 f5 bl ffc14bac <memset>
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
ffc0d3bc: 2f 9e 00 00 cmpwi cr7,r30,0
ffc0d3c0: 41 9e 00 64 beq- cr7,ffc0d424 <_User_extensions_Handler_initialization+0xec><== NEVER TAKEN
ffc0d3c4: 3b 80 00 00 li r28,0
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
ffc0d3c8: 81 5d 00 00 lwz r10,0(r29)
_User_extensions_Add_set( extension );
ffc0d3cc: 7f e3 fb 78 mr r3,r31
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
ffc0d3d0: 81 7d 00 04 lwz r11,4(r29)
ffc0d3d4: 3b 9c 00 01 addi r28,r28,1
ffc0d3d8: 81 3d 00 08 lwz r9,8(r29)
ffc0d3dc: 80 1d 00 0c lwz r0,12(r29)
ffc0d3e0: 91 5f 00 14 stw r10,20(r31)
ffc0d3e4: 91 7f 00 18 stw r11,24(r31)
ffc0d3e8: 91 3f 00 1c stw r9,28(r31)
ffc0d3ec: 90 1f 00 20 stw r0,32(r31)
ffc0d3f0: 81 5d 00 10 lwz r10,16(r29)
ffc0d3f4: 81 7d 00 14 lwz r11,20(r29)
ffc0d3f8: 81 3d 00 18 lwz r9,24(r29)
ffc0d3fc: 80 1d 00 1c lwz r0,28(r29)
ffc0d400: 3b bd 00 20 addi r29,r29,32
ffc0d404: 91 5f 00 24 stw r10,36(r31)
ffc0d408: 91 7f 00 28 stw r11,40(r31)
ffc0d40c: 91 3f 00 2c stw r9,44(r31)
ffc0d410: 90 1f 00 30 stw r0,48(r31)
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
ffc0d414: 3b ff 00 34 addi r31,r31,52
_User_extensions_Add_set( extension );
ffc0d418: 48 00 43 a5 bl ffc117bc <_User_extensions_Add_set>
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
ffc0d41c: 7f 9c f0 00 cmpw cr7,r28,r30
ffc0d420: 40 9e ff a8 bne+ cr7,ffc0d3c8 <_User_extensions_Handler_initialization+0x90>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
}
}
}
ffc0d424: 80 01 00 1c lwz r0,28(r1)
ffc0d428: 83 81 00 08 lwz r28,8(r1)
ffc0d42c: 7c 08 03 a6 mtlr r0
ffc0d430: 83 a1 00 0c lwz r29,12(r1)
ffc0d434: 83 c1 00 10 lwz r30,16(r1)
ffc0d438: 83 e1 00 14 lwz r31,20(r1)
ffc0d43c: 38 21 00 18 addi r1,r1,24
ffc0d440: 4e 80 00 20 blr
ffc0d444 <_User_extensions_Thread_begin>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_begin (
Thread_Control *executing
)
{
ffc0d444: 94 21 ff e8 stwu r1,-24(r1)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc0d448: 3d 20 00 00 lis r9,0
ffc0d44c: 7c 08 02 a6 mflr r0
ffc0d450: 93 c1 00 10 stw r30,16(r1)
ffc0d454: 3b c9 2d f4 addi r30,r9,11764
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
ffc0d458: 3b de 00 04 addi r30,r30,4
#include <rtems/score/userext.h>
void _User_extensions_Thread_begin (
Thread_Control *executing
)
{
ffc0d45c: 93 e1 00 14 stw r31,20(r1)
ffc0d460: 83 e9 2d f4 lwz r31,11764(r9)
ffc0d464: 93 a1 00 0c stw r29,12(r1)
ffc0d468: 7c 7d 1b 78 mr r29,r3
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
ffc0d46c: 7f 9f f0 00 cmpw cr7,r31,r30
#include <rtems/score/userext.h>
void _User_extensions_Thread_begin (
Thread_Control *executing
)
{
ffc0d470: 90 01 00 1c stw r0,28(r1)
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
ffc0d474: 41 9e 00 28 beq- cr7,ffc0d49c <_User_extensions_Thread_begin+0x58><== NEVER TAKEN
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_begin != NULL )
ffc0d478: 80 1f 00 28 lwz r0,40(r31)
(*the_extension->Callouts.thread_begin)( executing );
ffc0d47c: 7f a3 eb 78 mr r3,r29
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_begin != NULL )
ffc0d480: 2f 80 00 00 cmpwi cr7,r0,0
ffc0d484: 41 9e 00 0c beq- cr7,ffc0d490 <_User_extensions_Thread_begin+0x4c>
(*the_extension->Callouts.thread_begin)( executing );
ffc0d488: 7c 09 03 a6 mtctr r0
ffc0d48c: 4e 80 04 21 bctrl
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
ffc0d490: 83 ff 00 00 lwz r31,0(r31)
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
ffc0d494: 7f 9f f0 00 cmpw cr7,r31,r30
ffc0d498: 40 9e ff e0 bne+ cr7,ffc0d478 <_User_extensions_Thread_begin+0x34>
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_begin != NULL )
(*the_extension->Callouts.thread_begin)( executing );
}
}
ffc0d49c: 80 01 00 1c lwz r0,28(r1)
ffc0d4a0: 83 a1 00 0c lwz r29,12(r1)
ffc0d4a4: 7c 08 03 a6 mtlr r0
ffc0d4a8: 83 c1 00 10 lwz r30,16(r1)
ffc0d4ac: 83 e1 00 14 lwz r31,20(r1)
ffc0d4b0: 38 21 00 18 addi r1,r1,24
ffc0d4b4: 4e 80 00 20 blr
ffc0d5b8 <_User_extensions_Thread_create>:
#include <rtems/score/userext.h>
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
ffc0d5b8: 94 21 ff e8 stwu r1,-24(r1)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc0d5bc: 3d 20 00 00 lis r9,0
ffc0d5c0: 7c 08 02 a6 mflr r0
ffc0d5c4: 93 c1 00 10 stw r30,16(r1)
ffc0d5c8: 3b c9 2d f4 addi r30,r9,11764
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
ffc0d5cc: 3b de 00 04 addi r30,r30,4
#include <rtems/score/userext.h>
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
ffc0d5d0: 93 e1 00 14 stw r31,20(r1)
ffc0d5d4: 83 e9 2d f4 lwz r31,11764(r9)
ffc0d5d8: 93 a1 00 0c stw r29,12(r1)
ffc0d5dc: 7c 7d 1b 78 mr r29,r3
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
ffc0d5e0: 7f 9f f0 00 cmpw cr7,r31,r30
#include <rtems/score/userext.h>
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
ffc0d5e4: 90 01 00 1c stw r0,28(r1)
if ( !status )
return false;
}
}
return true;
ffc0d5e8: 38 60 00 01 li r3,1
#include <rtems/score/userext.h>
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
ffc0d5ec: 93 81 00 08 stw r28,8(r1)
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
ffc0d5f0: 41 9e 00 40 beq- cr7,ffc0d630 <_User_extensions_Thread_create+0x78><== NEVER TAKEN
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_create != NULL ) {
status = (*the_extension->Callouts.thread_create)(
ffc0d5f4: 3f 80 00 00 lis r28,0
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_create != NULL ) {
ffc0d5f8: 80 1f 00 14 lwz r0,20(r31)
status = (*the_extension->Callouts.thread_create)(
ffc0d5fc: 39 3c 31 44 addi r9,r28,12612
ffc0d600: 7f a4 eb 78 mr r4,r29
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_create != NULL ) {
ffc0d604: 2f 80 00 00 cmpwi cr7,r0,0
ffc0d608: 41 9e 00 18 beq- cr7,ffc0d620 <_User_extensions_Thread_create+0x68>
status = (*the_extension->Callouts.thread_create)(
ffc0d60c: 80 69 00 0c lwz r3,12(r9)
ffc0d610: 7c 09 03 a6 mtctr r0
ffc0d614: 4e 80 04 21 bctrl
_Thread_Executing,
the_thread
);
if ( !status )
ffc0d618: 2f 83 00 00 cmpwi cr7,r3,0
ffc0d61c: 41 9e 00 34 beq- cr7,ffc0d650 <_User_extensions_Thread_create+0x98>
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
ffc0d620: 83 ff 00 00 lwz r31,0(r31)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
ffc0d624: 7f 9f f0 00 cmpw cr7,r31,r30
ffc0d628: 40 9e ff d0 bne+ cr7,ffc0d5f8 <_User_extensions_Thread_create+0x40>
if ( !status )
return false;
}
}
return true;
ffc0d62c: 38 60 00 01 li r3,1
}
ffc0d630: 80 01 00 1c lwz r0,28(r1)
ffc0d634: 83 81 00 08 lwz r28,8(r1)
ffc0d638: 7c 08 03 a6 mtlr r0
ffc0d63c: 83 a1 00 0c lwz r29,12(r1)
ffc0d640: 83 c1 00 10 lwz r30,16(r1)
ffc0d644: 83 e1 00 14 lwz r31,20(r1)
ffc0d648: 38 21 00 18 addi r1,r1,24
ffc0d64c: 4e 80 00 20 blr
ffc0d650: 80 01 00 1c lwz r0,28(r1)
status = (*the_extension->Callouts.thread_create)(
_Thread_Executing,
the_thread
);
if ( !status )
return false;
ffc0d654: 38 60 00 00 li r3,0
}
}
return true;
}
ffc0d658: 83 81 00 08 lwz r28,8(r1)
ffc0d65c: 7c 08 03 a6 mtlr r0
ffc0d660: 83 a1 00 0c lwz r29,12(r1)
ffc0d664: 83 c1 00 10 lwz r30,16(r1)
ffc0d668: 83 e1 00 14 lwz r31,20(r1)
ffc0d66c: 38 21 00 18 addi r1,r1,24
ffc0d670: 4e 80 00 20 blr
ffc0d674 <_User_extensions_Thread_delete>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_delete (
Thread_Control *the_thread
)
{
ffc0d674: 94 21 ff e8 stwu r1,-24(r1)
ffc0d678: 7c 08 02 a6 mflr r0
ffc0d67c: 93 c1 00 10 stw r30,16(r1)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return _Chain_Tail( the_chain )->previous;
ffc0d680: 3f c0 00 00 lis r30,0
ffc0d684: 3b de 2d f4 addi r30,r30,11764
ffc0d688: 93 e1 00 14 stw r31,20(r1)
ffc0d68c: 83 fe 00 08 lwz r31,8(r30)
ffc0d690: 93 a1 00 0c stw r29,12(r1)
ffc0d694: 7c 7d 1b 78 mr r29,r3
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
ffc0d698: 7f 9f f0 00 cmpw cr7,r31,r30
#include <rtems/score/userext.h>
void _User_extensions_Thread_delete (
Thread_Control *the_thread
)
{
ffc0d69c: 90 01 00 1c stw r0,28(r1)
ffc0d6a0: 93 81 00 08 stw r28,8(r1)
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
ffc0d6a4: 41 9e 00 34 beq- cr7,ffc0d6d8 <_User_extensions_Thread_delete+0x64><== NEVER TAKEN
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_delete != NULL )
(*the_extension->Callouts.thread_delete)(
ffc0d6a8: 3f 80 00 00 lis r28,0
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_delete != NULL )
ffc0d6ac: 80 1f 00 20 lwz r0,32(r31)
(*the_extension->Callouts.thread_delete)(
ffc0d6b0: 39 3c 31 44 addi r9,r28,12612
ffc0d6b4: 7f a4 eb 78 mr r4,r29
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_delete != NULL )
ffc0d6b8: 2f 80 00 00 cmpwi cr7,r0,0
ffc0d6bc: 41 9e 00 10 beq- cr7,ffc0d6cc <_User_extensions_Thread_delete+0x58>
(*the_extension->Callouts.thread_delete)(
ffc0d6c0: 80 69 00 0c lwz r3,12(r9)
ffc0d6c4: 7c 09 03 a6 mtctr r0
ffc0d6c8: 4e 80 04 21 bctrl
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
ffc0d6cc: 83 ff 00 04 lwz r31,4(r31)
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
ffc0d6d0: 7f 9f f0 00 cmpw cr7,r31,r30
ffc0d6d4: 40 9e ff d8 bne+ cr7,ffc0d6ac <_User_extensions_Thread_delete+0x38>
(*the_extension->Callouts.thread_delete)(
_Thread_Executing,
the_thread
);
}
}
ffc0d6d8: 80 01 00 1c lwz r0,28(r1)
ffc0d6dc: 83 81 00 08 lwz r28,8(r1)
ffc0d6e0: 7c 08 03 a6 mtlr r0
ffc0d6e4: 83 a1 00 0c lwz r29,12(r1)
ffc0d6e8: 83 c1 00 10 lwz r30,16(r1)
ffc0d6ec: 83 e1 00 14 lwz r31,20(r1)
ffc0d6f0: 38 21 00 18 addi r1,r1,24
ffc0d6f4: 4e 80 00 20 blr
ffc0d4b8 <_User_extensions_Thread_exitted>:
void _User_extensions_Thread_exitted (
Thread_Control *executing
)
{
ffc0d4b8: 94 21 ff e8 stwu r1,-24(r1)
ffc0d4bc: 7c 08 02 a6 mflr r0
ffc0d4c0: 93 c1 00 10 stw r30,16(r1)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return _Chain_Tail( the_chain )->previous;
ffc0d4c4: 3f c0 00 00 lis r30,0
ffc0d4c8: 3b de 2d f4 addi r30,r30,11764
ffc0d4cc: 93 e1 00 14 stw r31,20(r1)
ffc0d4d0: 83 fe 00 08 lwz r31,8(r30)
ffc0d4d4: 93 a1 00 0c stw r29,12(r1)
ffc0d4d8: 7c 7d 1b 78 mr r29,r3
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
ffc0d4dc: 7f 9f f0 00 cmpw cr7,r31,r30
}
void _User_extensions_Thread_exitted (
Thread_Control *executing
)
{
ffc0d4e0: 90 01 00 1c stw r0,28(r1)
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
ffc0d4e4: 41 9e 00 28 beq- cr7,ffc0d50c <_User_extensions_Thread_exitted+0x54><== NEVER TAKEN
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_exitted != NULL )
ffc0d4e8: 80 1f 00 2c lwz r0,44(r31)
(*the_extension->Callouts.thread_exitted)( executing );
ffc0d4ec: 7f a3 eb 78 mr r3,r29
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_exitted != NULL )
ffc0d4f0: 2f 80 00 00 cmpwi cr7,r0,0
ffc0d4f4: 41 9e 00 0c beq- cr7,ffc0d500 <_User_extensions_Thread_exitted+0x48>
(*the_extension->Callouts.thread_exitted)( executing );
ffc0d4f8: 7c 09 03 a6 mtctr r0
ffc0d4fc: 4e 80 04 21 bctrl
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
ffc0d500: 83 ff 00 04 lwz r31,4(r31)
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
ffc0d504: 7f 9f f0 00 cmpw cr7,r31,r30
ffc0d508: 40 9e ff e0 bne+ cr7,ffc0d4e8 <_User_extensions_Thread_exitted+0x30>
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_exitted != NULL )
(*the_extension->Callouts.thread_exitted)( executing );
}
}
ffc0d50c: 80 01 00 1c lwz r0,28(r1)
ffc0d510: 83 a1 00 0c lwz r29,12(r1)
ffc0d514: 7c 08 03 a6 mtlr r0
ffc0d518: 83 c1 00 10 lwz r30,16(r1)
ffc0d51c: 83 e1 00 14 lwz r31,20(r1)
ffc0d520: 38 21 00 18 addi r1,r1,24
ffc0d524: 4e 80 00 20 blr
ffc0e274 <_User_extensions_Thread_restart>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_restart (
Thread_Control *the_thread
)
{
ffc0e274: 94 21 ff e8 stwu r1,-24(r1)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc0e278: 3d 20 00 00 lis r9,0
ffc0e27c: 7c 08 02 a6 mflr r0
ffc0e280: 93 c1 00 10 stw r30,16(r1)
ffc0e284: 3b c9 2e 14 addi r30,r9,11796
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
ffc0e288: 3b de 00 04 addi r30,r30,4
#include <rtems/score/userext.h>
void _User_extensions_Thread_restart (
Thread_Control *the_thread
)
{
ffc0e28c: 93 e1 00 14 stw r31,20(r1)
ffc0e290: 83 e9 2e 14 lwz r31,11796(r9)
ffc0e294: 93 a1 00 0c stw r29,12(r1)
ffc0e298: 7c 7d 1b 78 mr r29,r3
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
ffc0e29c: 7f 9f f0 00 cmpw cr7,r31,r30
#include <rtems/score/userext.h>
void _User_extensions_Thread_restart (
Thread_Control *the_thread
)
{
ffc0e2a0: 90 01 00 1c stw r0,28(r1)
ffc0e2a4: 93 81 00 08 stw r28,8(r1)
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
ffc0e2a8: 41 9e 00 34 beq- cr7,ffc0e2dc <_User_extensions_Thread_restart+0x68><== NEVER TAKEN
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_restart != NULL )
(*the_extension->Callouts.thread_restart)(
ffc0e2ac: 3f 80 00 00 lis r28,0
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_restart != NULL )
ffc0e2b0: 80 1f 00 1c lwz r0,28(r31)
(*the_extension->Callouts.thread_restart)(
ffc0e2b4: 39 3c 31 64 addi r9,r28,12644
ffc0e2b8: 7f a4 eb 78 mr r4,r29
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_restart != NULL )
ffc0e2bc: 2f 80 00 00 cmpwi cr7,r0,0
ffc0e2c0: 41 9e 00 10 beq- cr7,ffc0e2d0 <_User_extensions_Thread_restart+0x5c>
(*the_extension->Callouts.thread_restart)(
ffc0e2c4: 80 69 00 0c lwz r3,12(r9)
ffc0e2c8: 7c 09 03 a6 mtctr r0
ffc0e2cc: 4e 80 04 21 bctrl
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
ffc0e2d0: 83 ff 00 00 lwz r31,0(r31)
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
ffc0e2d4: 7f 9f f0 00 cmpw cr7,r31,r30
ffc0e2d8: 40 9e ff d8 bne+ cr7,ffc0e2b0 <_User_extensions_Thread_restart+0x3c>
(*the_extension->Callouts.thread_restart)(
_Thread_Executing,
the_thread
);
}
}
ffc0e2dc: 80 01 00 1c lwz r0,28(r1)
ffc0e2e0: 83 81 00 08 lwz r28,8(r1)
ffc0e2e4: 7c 08 03 a6 mtlr r0
ffc0e2e8: 83 a1 00 0c lwz r29,12(r1)
ffc0e2ec: 83 c1 00 10 lwz r30,16(r1)
ffc0e2f0: 83 e1 00 14 lwz r31,20(r1)
ffc0e2f4: 38 21 00 18 addi r1,r1,24
ffc0e2f8: 4e 80 00 20 blr
ffc0d6f8 <_User_extensions_Thread_start>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_start (
Thread_Control *the_thread
)
{
ffc0d6f8: 94 21 ff e8 stwu r1,-24(r1)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc0d6fc: 3d 20 00 00 lis r9,0
ffc0d700: 7c 08 02 a6 mflr r0
ffc0d704: 93 c1 00 10 stw r30,16(r1)
ffc0d708: 3b c9 2d f4 addi r30,r9,11764
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
ffc0d70c: 3b de 00 04 addi r30,r30,4
#include <rtems/score/userext.h>
void _User_extensions_Thread_start (
Thread_Control *the_thread
)
{
ffc0d710: 93 e1 00 14 stw r31,20(r1)
ffc0d714: 83 e9 2d f4 lwz r31,11764(r9)
ffc0d718: 93 a1 00 0c stw r29,12(r1)
ffc0d71c: 7c 7d 1b 78 mr r29,r3
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
ffc0d720: 7f 9f f0 00 cmpw cr7,r31,r30
#include <rtems/score/userext.h>
void _User_extensions_Thread_start (
Thread_Control *the_thread
)
{
ffc0d724: 90 01 00 1c stw r0,28(r1)
ffc0d728: 93 81 00 08 stw r28,8(r1)
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
ffc0d72c: 41 9e 00 34 beq- cr7,ffc0d760 <_User_extensions_Thread_start+0x68><== NEVER TAKEN
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_start != NULL )
(*the_extension->Callouts.thread_start)(
ffc0d730: 3f 80 00 00 lis r28,0
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_start != NULL )
ffc0d734: 80 1f 00 18 lwz r0,24(r31)
(*the_extension->Callouts.thread_start)(
ffc0d738: 39 3c 31 44 addi r9,r28,12612
ffc0d73c: 7f a4 eb 78 mr r4,r29
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_start != NULL )
ffc0d740: 2f 80 00 00 cmpwi cr7,r0,0
ffc0d744: 41 9e 00 10 beq- cr7,ffc0d754 <_User_extensions_Thread_start+0x5c>
(*the_extension->Callouts.thread_start)(
ffc0d748: 80 69 00 0c lwz r3,12(r9)
ffc0d74c: 7c 09 03 a6 mtctr r0
ffc0d750: 4e 80 04 21 bctrl
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
ffc0d754: 83 ff 00 00 lwz r31,0(r31)
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
ffc0d758: 7f 9f f0 00 cmpw cr7,r31,r30
ffc0d75c: 40 9e ff d8 bne+ cr7,ffc0d734 <_User_extensions_Thread_start+0x3c>
(*the_extension->Callouts.thread_start)(
_Thread_Executing,
the_thread
);
}
}
ffc0d760: 80 01 00 1c lwz r0,28(r1)
ffc0d764: 83 81 00 08 lwz r28,8(r1)
ffc0d768: 7c 08 03 a6 mtlr r0
ffc0d76c: 83 a1 00 0c lwz r29,12(r1)
ffc0d770: 83 c1 00 10 lwz r30,16(r1)
ffc0d774: 83 e1 00 14 lwz r31,20(r1)
ffc0d778: 38 21 00 18 addi r1,r1,24
ffc0d77c: 4e 80 00 20 blr
ffc0d780 <_User_extensions_Thread_switch>:
void _User_extensions_Thread_switch (
Thread_Control *executing,
Thread_Control *heir
)
{
ffc0d780: 94 21 ff e8 stwu r1,-24(r1)
ffc0d784: 3d 20 00 00 lis r9,0
ffc0d788: 7c 08 02 a6 mflr r0
ffc0d78c: 93 c1 00 10 stw r30,16(r1)
ffc0d790: 3b c9 2c d0 addi r30,r9,11472
Chain_Node *the_node;
User_extensions_Switch_control *the_extension_switch;
for ( the_node = _Chain_First( &_User_extensions_Switches_list );
ffc0d794: 3b de 00 04 addi r30,r30,4
void _User_extensions_Thread_switch (
Thread_Control *executing,
Thread_Control *heir
)
{
ffc0d798: 93 e1 00 14 stw r31,20(r1)
ffc0d79c: 83 e9 2c d0 lwz r31,11472(r9)
ffc0d7a0: 93 81 00 08 stw r28,8(r1)
ffc0d7a4: 7c 7c 1b 78 mr r28,r3
Chain_Node *the_node;
User_extensions_Switch_control *the_extension_switch;
for ( the_node = _Chain_First( &_User_extensions_Switches_list );
ffc0d7a8: 7f 9f f0 00 cmpw cr7,r31,r30
void _User_extensions_Thread_switch (
Thread_Control *executing,
Thread_Control *heir
)
{
ffc0d7ac: 93 a1 00 0c stw r29,12(r1)
ffc0d7b0: 7c 9d 23 78 mr r29,r4
ffc0d7b4: 90 01 00 1c stw r0,28(r1)
Chain_Node *the_node;
User_extensions_Switch_control *the_extension_switch;
for ( the_node = _Chain_First( &_User_extensions_Switches_list );
ffc0d7b8: 41 9e 00 24 beq- cr7,ffc0d7dc <_User_extensions_Thread_switch+0x5c><== NEVER TAKEN
!_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ;
the_node = the_node->next ) {
the_extension_switch = (User_extensions_Switch_control *) the_node;
(*the_extension_switch->thread_switch)( executing, heir );
ffc0d7bc: 80 1f 00 08 lwz r0,8(r31)
ffc0d7c0: 7f 83 e3 78 mr r3,r28
ffc0d7c4: 7f a4 eb 78 mr r4,r29
ffc0d7c8: 7c 09 03 a6 mtctr r0
ffc0d7cc: 4e 80 04 21 bctrl
Chain_Node *the_node;
User_extensions_Switch_control *the_extension_switch;
for ( the_node = _Chain_First( &_User_extensions_Switches_list );
!_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ;
the_node = the_node->next ) {
ffc0d7d0: 83 ff 00 00 lwz r31,0(r31)
)
{
Chain_Node *the_node;
User_extensions_Switch_control *the_extension_switch;
for ( the_node = _Chain_First( &_User_extensions_Switches_list );
ffc0d7d4: 7f 9f f0 00 cmpw cr7,r31,r30
ffc0d7d8: 40 9e ff e4 bne+ cr7,ffc0d7bc <_User_extensions_Thread_switch+0x3c>
the_extension_switch = (User_extensions_Switch_control *) the_node;
(*the_extension_switch->thread_switch)( executing, heir );
}
}
ffc0d7dc: 80 01 00 1c lwz r0,28(r1)
ffc0d7e0: 83 81 00 08 lwz r28,8(r1)
ffc0d7e4: 7c 08 03 a6 mtlr r0
ffc0d7e8: 83 a1 00 0c lwz r29,12(r1)
ffc0d7ec: 83 c1 00 10 lwz r30,16(r1)
ffc0d7f0: 83 e1 00 14 lwz r31,20(r1)
ffc0d7f4: 38 21 00 18 addi r1,r1,24
ffc0d7f8: 4e 80 00 20 blr
ffc0f68c <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
ffc0f68c: 94 21 ff e0 stwu r1,-32(r1)
ffc0f690: 7c 08 02 a6 mflr r0
ffc0f694: 90 01 00 24 stw r0,36(r1)
ffc0f698: 93 c1 00 18 stw r30,24(r1)
ffc0f69c: 7c be 2b 78 mr r30,r5
ffc0f6a0: 93 e1 00 1c stw r31,28(r1)
ffc0f6a4: 7c 7f 1b 78 mr r31,r3
ffc0f6a8: 93 61 00 0c stw r27,12(r1)
ffc0f6ac: 93 81 00 10 stw r28,16(r1)
ffc0f6b0: 93 a1 00 14 stw r29,20(r1)
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0f6b4: 7c 00 00 a6 mfmsr r0
ffc0f6b8: 7d 30 42 a6 mfsprg r9,0
ffc0f6bc: 7c 09 48 78 andc r9,r0,r9
ffc0f6c0: 7d 20 01 24 mtmsr r9
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
ffc0f6c4: 81 23 00 00 lwz r9,0(r3)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
ffc0f6c8: 3b 83 00 04 addi r28,r3,4
* hence the compiler must not assume *header to remain
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
ffc0f6cc: 7f 89 e0 00 cmpw cr7,r9,r28
ffc0f6d0: 41 9e 00 68 beq- cr7,ffc0f738 <_Watchdog_Adjust+0xac>
switch ( direction ) {
ffc0f6d4: 2f 84 00 00 cmpwi cr7,r4,0
ffc0f6d8: 40 9e 00 88 bne- cr7,ffc0f760 <_Watchdog_Adjust+0xd4>
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
ffc0f6dc: 2f 85 00 00 cmpwi cr7,r5,0
ffc0f6e0: 41 9e 00 58 beq- cr7,ffc0f738 <_Watchdog_Adjust+0xac> <== NEVER TAKEN
if ( units < _Watchdog_First( header )->delta_interval ) {
ffc0f6e4: 83 a9 00 10 lwz r29,16(r9)
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
ffc0f6e8: 3b 60 00 01 li r27,1
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
ffc0f6ec: 7f 85 e8 40 cmplw cr7,r5,r29
ffc0f6f0: 40 bc 00 18 bge+ cr7,ffc0f708 <_Watchdog_Adjust+0x7c> <== ALWAYS TAKEN
ffc0f6f4: 48 00 00 a8 b ffc0f79c <_Watchdog_Adjust+0x110> <== NOT EXECUTED
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
ffc0f6f8: 41 82 00 40 beq- ffc0f738 <_Watchdog_Adjust+0xac> <== NEVER TAKEN
if ( units < _Watchdog_First( header )->delta_interval ) {
ffc0f6fc: 83 a9 00 10 lwz r29,16(r9)
ffc0f700: 7f 9d f0 40 cmplw cr7,r29,r30
ffc0f704: 41 9d 00 98 bgt- cr7,ffc0f79c <_Watchdog_Adjust+0x110>
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
ffc0f708: 93 69 00 10 stw r27,16(r9)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0f70c: 7c 00 01 24 mtmsr r0
_ISR_Enable( level );
_Watchdog_Tickle( header );
ffc0f710: 7f e3 fb 78 mr r3,r31
ffc0f714: 48 00 03 2d bl ffc0fa40 <_Watchdog_Tickle>
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0f718: 7c 00 00 a6 mfmsr r0
ffc0f71c: 7d 30 42 a6 mfsprg r9,0
ffc0f720: 7c 09 48 78 andc r9,r0,r9
ffc0f724: 7d 20 01 24 mtmsr r9
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
ffc0f728: 81 3f 00 00 lwz r9,0(r31)
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
ffc0f72c: 7f dd f0 51 subf. r30,r29,r30
_Watchdog_Tickle( header );
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
ffc0f730: 7f 9c 48 00 cmpw cr7,r28,r9
ffc0f734: 40 9e ff c4 bne+ cr7,ffc0f6f8 <_Watchdog_Adjust+0x6c>
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0f738: 7c 00 01 24 mtmsr r0
}
}
_ISR_Enable( level );
}
ffc0f73c: 80 01 00 24 lwz r0,36(r1)
ffc0f740: 83 61 00 0c lwz r27,12(r1)
ffc0f744: 7c 08 03 a6 mtlr r0
ffc0f748: 83 81 00 10 lwz r28,16(r1)
ffc0f74c: 83 a1 00 14 lwz r29,20(r1)
ffc0f750: 83 c1 00 18 lwz r30,24(r1)
ffc0f754: 83 e1 00 1c lwz r31,28(r1)
ffc0f758: 38 21 00 20 addi r1,r1,32
ffc0f75c: 4e 80 00 20 blr
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
ffc0f760: 2f 84 00 01 cmpwi cr7,r4,1
ffc0f764: 40 9e ff d4 bne+ cr7,ffc0f738 <_Watchdog_Adjust+0xac> <== NEVER TAKEN
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
ffc0f768: 81 69 00 10 lwz r11,16(r9)
ffc0f76c: 7f cb 2a 14 add r30,r11,r5
ffc0f770: 93 c9 00 10 stw r30,16(r9)
ffc0f774: 7c 00 01 24 mtmsr r0
}
}
_ISR_Enable( level );
}
ffc0f778: 80 01 00 24 lwz r0,36(r1)
ffc0f77c: 83 61 00 0c lwz r27,12(r1)
ffc0f780: 7c 08 03 a6 mtlr r0
ffc0f784: 83 81 00 10 lwz r28,16(r1)
ffc0f788: 83 a1 00 14 lwz r29,20(r1)
ffc0f78c: 83 c1 00 18 lwz r30,24(r1)
ffc0f790: 83 e1 00 1c lwz r31,28(r1)
ffc0f794: 38 21 00 20 addi r1,r1,32
ffc0f798: 4e 80 00 20 blr
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
ffc0f79c: 7f de e8 50 subf r30,r30,r29
ffc0f7a0: 93 c9 00 10 stw r30,16(r9)
break;
ffc0f7a4: 4b ff ff 94 b ffc0f738 <_Watchdog_Adjust+0xac>
ffc0d7fc <_Watchdog_Insert>:
Watchdog_Control *after;
uint32_t insert_isr_nest_level;
Watchdog_Interval delta_interval;
insert_isr_nest_level = _ISR_Nest_level;
ffc0d7fc: 3d 20 00 00 lis r9,0
ffc0d800: 80 09 31 4c lwz r0,12620(r9)
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0d804: 7d 00 00 a6 mfmsr r8
ffc0d808: 7d 30 42 a6 mfsprg r9,0
ffc0d80c: 7d 09 48 78 andc r9,r8,r9
ffc0d810: 7d 20 01 24 mtmsr r9
/*
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
ffc0d814: 81 24 00 08 lwz r9,8(r4)
ffc0d818: 2f 89 00 00 cmpwi cr7,r9,0
ffc0d81c: 40 9e 01 04 bne- cr7,ffc0d920 <_Watchdog_Insert+0x124>
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
_Watchdog_Sync_count++;
ffc0d820: 3c c0 00 00 lis r6,0
ffc0d824: 81 26 28 3c lwz r9,10300(r6)
if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
ffc0d828: 39 60 00 01 li r11,1
ffc0d82c: 91 64 00 08 stw r11,8(r4)
ffc0d830: 3c a0 00 00 lis r5,0
_Watchdog_Sync_count++;
ffc0d834: 39 29 00 01 addi r9,r9,1
ffc0d838: 91 26 28 3c stw r9,10300(r6)
restart:
delta_interval = the_watchdog->initial;
ffc0d83c: 81 24 00 0c lwz r9,12(r4)
ffc0d840: 81 63 00 00 lwz r11,0(r3)
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
ffc0d844: 2f 89 00 00 cmpwi cr7,r9,0
ffc0d848: 41 9e 00 98 beq- cr7,ffc0d8e0 <_Watchdog_Insert+0xe4>
ffc0d84c: 81 4b 00 00 lwz r10,0(r11)
ffc0d850: 2f 8a 00 00 cmpwi cr7,r10,0
ffc0d854: 41 9e 00 8c beq- cr7,ffc0d8e0 <_Watchdog_Insert+0xe4>
break;
if ( delta_interval < after->delta_interval ) {
ffc0d858: 81 4b 00 10 lwz r10,16(r11)
ffc0d85c: 7f 89 50 40 cmplw cr7,r9,r10
ffc0d860: 41 9c 00 c8 blt- cr7,ffc0d928 <_Watchdog_Insert+0x12c>
static inline void ppc_interrupt_flash( uint32_t level )
{
uint32_t current_level;
__asm__ volatile (
ffc0d864: 7c e0 00 a6 mfmsr r7
ffc0d868: 7d 00 01 24 mtmsr r8
ffc0d86c: 7c e0 01 24 mtmsr r7
delta_interval -= after->delta_interval;
_ISR_Flash( level );
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
ffc0d870: 80 e4 00 08 lwz r7,8(r4)
ffc0d874: 2f 87 00 01 cmpwi cr7,r7,1
ffc0d878: 40 9e 00 98 bne- cr7,ffc0d910 <_Watchdog_Insert+0x114>
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
ffc0d87c: 81 85 28 34 lwz r12,10292(r5)
ffc0d880: 38 e5 28 34 addi r7,r5,10292
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
break;
}
delta_interval -= after->delta_interval;
ffc0d884: 7d 2a 48 50 subf r9,r10,r9
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
ffc0d888: 7f 80 60 40 cmplw cr7,r0,r12
ffc0d88c: 40 bc 00 48 bge+ cr7,ffc0d8d4 <_Watchdog_Insert+0xd8>
ffc0d890: 48 00 00 d4 b ffc0d964 <_Watchdog_Insert+0x168>
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
ffc0d894: 81 4b 00 00 lwz r10,0(r11)
ffc0d898: 2f 8a 00 00 cmpwi cr7,r10,0
ffc0d89c: 41 9e 00 44 beq- cr7,ffc0d8e0 <_Watchdog_Insert+0xe4>
break;
if ( delta_interval < after->delta_interval ) {
ffc0d8a0: 81 4b 00 10 lwz r10,16(r11)
ffc0d8a4: 7f 8a 48 40 cmplw cr7,r10,r9
ffc0d8a8: 41 9d 00 80 bgt- cr7,ffc0d928 <_Watchdog_Insert+0x12c>
after->delta_interval -= delta_interval;
break;
}
delta_interval -= after->delta_interval;
ffc0d8ac: 7d 2a 48 50 subf r9,r10,r9
ffc0d8b0: 7d 40 00 a6 mfmsr r10
ffc0d8b4: 7d 00 01 24 mtmsr r8
ffc0d8b8: 7d 40 01 24 mtmsr r10
_ISR_Flash( level );
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
ffc0d8bc: 81 44 00 08 lwz r10,8(r4)
ffc0d8c0: 2f 8a 00 01 cmpwi cr7,r10,1
ffc0d8c4: 40 9e 00 4c bne- cr7,ffc0d910 <_Watchdog_Insert+0x114> <== NEVER TAKEN
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
ffc0d8c8: 81 47 00 00 lwz r10,0(r7)
ffc0d8cc: 7f 80 50 40 cmplw cr7,r0,r10
ffc0d8d0: 41 9c 00 94 blt- cr7,ffc0d964 <_Watchdog_Insert+0x168> <== NEVER TAKEN
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
ffc0d8d4: 2f 89 00 00 cmpwi cr7,r9,0
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
_Watchdog_Sync_count--;
_ISR_Enable( level );
}
ffc0d8d8: 81 6b 00 00 lwz r11,0(r11)
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
ffc0d8dc: 40 9e ff b8 bne+ cr7,ffc0d894 <_Watchdog_Insert+0x98>
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
ffc0d8e0: 81 6b 00 04 lwz r11,4(r11)
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
ffc0d8e4: 3c e0 00 00 lis r7,0
ffc0d8e8: 80 e7 28 40 lwz r7,10304(r7)
RTEMS_INLINE_ROUTINE void _Watchdog_Activate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_ACTIVE;
ffc0d8ec: 38 60 00 02 li r3,2
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
ffc0d8f0: 81 4b 00 00 lwz r10,0(r11)
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
ffc0d8f4: 91 64 00 04 stw r11,4(r4)
ffc0d8f8: 90 64 00 08 stw r3,8(r4)
}
}
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
ffc0d8fc: 91 24 00 10 stw r9,16(r4)
before_node = after_node->next;
after_node->next = the_node;
ffc0d900: 90 8b 00 00 stw r4,0(r11)
the_node->next = before_node;
before_node->previous = the_node;
ffc0d904: 90 8a 00 04 stw r4,4(r10)
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
the_node->next = before_node;
ffc0d908: 91 44 00 00 stw r10,0(r4)
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
ffc0d90c: 90 e4 00 14 stw r7,20(r4)
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
ffc0d910: 90 05 28 34 stw r0,10292(r5)
_Watchdog_Sync_count--;
ffc0d914: 81 26 28 3c lwz r9,10300(r6)
ffc0d918: 38 09 ff ff addi r0,r9,-1
ffc0d91c: 90 06 28 3c stw r0,10300(r6)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0d920: 7d 00 01 24 mtmsr r8
ffc0d924: 4e 80 00 20 blr
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
break;
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
ffc0d928: 7d 49 50 50 subf r10,r9,r10
ffc0d92c: 91 4b 00 10 stw r10,16(r11)
the_watchdog->delta_interval = delta_interval;
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
ffc0d930: 3c e0 00 00 lis r7,0
ffc0d934: 38 60 00 02 li r3,2
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
ffc0d938: 81 6b 00 04 lwz r11,4(r11)
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
ffc0d93c: 80 e7 28 40 lwz r7,10304(r7)
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
ffc0d940: 81 4b 00 00 lwz r10,0(r11)
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
ffc0d944: 91 64 00 04 stw r11,4(r4)
ffc0d948: 90 64 00 08 stw r3,8(r4)
}
}
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
ffc0d94c: 91 24 00 10 stw r9,16(r4)
before_node = after_node->next;
after_node->next = the_node;
ffc0d950: 90 8b 00 00 stw r4,0(r11)
the_node->next = before_node;
before_node->previous = the_node;
ffc0d954: 90 8a 00 04 stw r4,4(r10)
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
the_node->next = before_node;
ffc0d958: 91 44 00 00 stw r10,0(r4)
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
ffc0d95c: 90 e4 00 14 stw r7,20(r4)
ffc0d960: 4b ff ff b0 b ffc0d910 <_Watchdog_Insert+0x114>
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
_Watchdog_Sync_level = insert_isr_nest_level;
ffc0d964: 90 05 28 34 stw r0,10292(r5)
goto restart;
ffc0d968: 4b ff fe d4 b ffc0d83c <_Watchdog_Insert+0x40>
ffc0d9c4 <_Watchdog_Remove>:
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0d9c4: 7d 20 00 a6 mfmsr r9
ffc0d9c8: 7c 10 42 a6 mfsprg r0,0
ffc0d9cc: 7d 20 00 78 andc r0,r9,r0
ffc0d9d0: 7c 00 01 24 mtmsr r0
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
previous_state = the_watchdog->state;
ffc0d9d4: 80 03 00 08 lwz r0,8(r3)
switch ( previous_state ) {
ffc0d9d8: 2f 80 00 01 cmpwi cr7,r0,1
ffc0d9dc: 41 9e 00 98 beq- cr7,ffc0da74 <_Watchdog_Remove+0xb0>
ffc0d9e0: 2b 80 00 01 cmplwi cr7,r0,1
ffc0d9e4: 40 9c 00 1c bge- cr7,ffc0da00 <_Watchdog_Remove+0x3c>
_Watchdog_Sync_level = _ISR_Nest_level;
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
ffc0d9e8: 3d 60 00 00 lis r11,0
ffc0d9ec: 81 6b 28 40 lwz r11,10304(r11)
ffc0d9f0: 91 63 00 18 stw r11,24(r3)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0d9f4: 7d 20 01 24 mtmsr r9
_ISR_Enable( level );
return( previous_state );
}
ffc0d9f8: 7c 03 03 78 mr r3,r0
ffc0d9fc: 4e 80 00 20 blr
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
previous_state = the_watchdog->state;
switch ( previous_state ) {
ffc0da00: 2b 80 00 03 cmplwi cr7,r0,3
ffc0da04: 41 bd ff e4 bgt- cr7,ffc0d9e8 <_Watchdog_Remove+0x24> <== NEVER TAKEN
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
ffc0da08: 39 60 00 00 li r11,0
ffc0da0c: 91 63 00 08 stw r11,8(r3)
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
_ISR_Enable( level );
return( previous_state );
}
ffc0da10: 81 63 00 00 lwz r11,0(r3)
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
next_watchdog = _Watchdog_Next( the_watchdog );
if ( _Watchdog_Next(next_watchdog) )
ffc0da14: 81 4b 00 00 lwz r10,0(r11)
ffc0da18: 2f 8a 00 00 cmpwi cr7,r10,0
ffc0da1c: 41 9e 00 14 beq- cr7,ffc0da30 <_Watchdog_Remove+0x6c>
next_watchdog->delta_interval += the_watchdog->delta_interval;
ffc0da20: 81 0b 00 10 lwz r8,16(r11)
ffc0da24: 81 43 00 10 lwz r10,16(r3)
ffc0da28: 7d 48 52 14 add r10,r8,r10
ffc0da2c: 91 4b 00 10 stw r10,16(r11)
if ( _Watchdog_Sync_count )
ffc0da30: 3d 40 00 00 lis r10,0
ffc0da34: 81 4a 28 3c lwz r10,10300(r10)
ffc0da38: 2f 8a 00 00 cmpwi cr7,r10,0
ffc0da3c: 41 9e 00 14 beq- cr7,ffc0da50 <_Watchdog_Remove+0x8c>
_Watchdog_Sync_level = _ISR_Nest_level;
ffc0da40: 3d 40 00 00 lis r10,0
ffc0da44: 81 0a 31 4c lwz r8,12620(r10)
ffc0da48: 3d 40 00 00 lis r10,0
ffc0da4c: 91 0a 28 34 stw r8,10292(r10)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
ffc0da50: 81 43 00 04 lwz r10,4(r3)
next->previous = previous;
ffc0da54: 91 4b 00 04 stw r10,4(r11)
previous->next = next;
ffc0da58: 91 6a 00 00 stw r11,0(r10)
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
ffc0da5c: 3d 60 00 00 lis r11,0
ffc0da60: 81 6b 28 40 lwz r11,10304(r11)
ffc0da64: 91 63 00 18 stw r11,24(r3)
ffc0da68: 7d 20 01 24 mtmsr r9
_ISR_Enable( level );
return( previous_state );
}
ffc0da6c: 7c 03 03 78 mr r3,r0
ffc0da70: 4e 80 00 20 blr
/*
* 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;
ffc0da74: 39 60 00 00 li r11,0
ffc0da78: 91 63 00 08 stw r11,8(r3)
_Watchdog_Sync_level = _ISR_Nest_level;
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
ffc0da7c: 3d 60 00 00 lis r11,0
ffc0da80: 81 6b 28 40 lwz r11,10304(r11)
ffc0da84: 91 63 00 18 stw r11,24(r3)
ffc0da88: 7d 20 01 24 mtmsr r9
_ISR_Enable( level );
return( previous_state );
}
ffc0da8c: 7c 03 03 78 mr r3,r0
ffc0da90: 4e 80 00 20 blr
ffc0edb8 <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
ffc0edb8: 94 21 ff e8 stwu r1,-24(r1)
ffc0edbc: 7c 08 02 a6 mflr r0
ffc0edc0: 93 c1 00 10 stw r30,16(r1)
ffc0edc4: 7c 7e 1b 78 mr r30,r3
ffc0edc8: 93 e1 00 14 stw r31,20(r1)
ffc0edcc: 7c 9f 23 78 mr r31,r4
ffc0edd0: 90 01 00 1c stw r0,28(r1)
ffc0edd4: 93 81 00 08 stw r28,8(r1)
ffc0edd8: 93 a1 00 0c stw r29,12(r1)
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0eddc: 7f a0 00 a6 mfmsr r29
ffc0ede0: 7c 10 42 a6 mfsprg r0,0
ffc0ede4: 7f a0 00 78 andc r0,r29,r0
ffc0ede8: 7c 00 01 24 mtmsr r0
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
ffc0edec: 3c 60 ff c2 lis r3,-62
ffc0edf0: 7f e5 fb 78 mr r5,r31
ffc0edf4: 38 63 2e 30 addi r3,r3,11824
ffc0edf8: 7f c4 f3 78 mr r4,r30
ffc0edfc: 4c c6 31 82 crclr 4*cr1+eq
ffc0ee00: 4b ff 80 09 bl ffc06e08 <printk>
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
ffc0ee04: 83 9f 00 00 lwz r28,0(r31)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
ffc0ee08: 3b ff 00 04 addi r31,r31,4
if ( !_Chain_Is_empty( header ) ) {
ffc0ee0c: 7f 9c f8 00 cmpw cr7,r28,r31
ffc0ee10: 41 9e 00 54 beq- cr7,ffc0ee64 <_Watchdog_Report_chain+0xac>
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
ffc0ee14: 7f 84 e3 78 mr r4,r28
ffc0ee18: 38 60 00 00 li r3,0
ffc0ee1c: 48 00 00 5d bl ffc0ee78 <_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 )
ffc0ee20: 83 9c 00 00 lwz r28,0(r28)
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
for ( node = _Chain_First( header ) ;
ffc0ee24: 7f 9c f8 00 cmpw cr7,r28,r31
ffc0ee28: 40 9e ff ec bne+ cr7,ffc0ee14 <_Watchdog_Report_chain+0x5c><== NEVER TAKEN
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
ffc0ee2c: 3c 60 ff c2 lis r3,-62
ffc0ee30: 38 63 2e 48 addi r3,r3,11848
ffc0ee34: 7f c4 f3 78 mr r4,r30
ffc0ee38: 4c c6 31 82 crclr 4*cr1+eq
ffc0ee3c: 4b ff 7f cd bl ffc06e08 <printk>
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0ee40: 7f a0 01 24 mtmsr r29
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
}
ffc0ee44: 80 01 00 1c lwz r0,28(r1)
ffc0ee48: 83 81 00 08 lwz r28,8(r1)
ffc0ee4c: 7c 08 03 a6 mtlr r0
ffc0ee50: 83 a1 00 0c lwz r29,12(r1)
ffc0ee54: 83 c1 00 10 lwz r30,16(r1)
ffc0ee58: 83 e1 00 14 lwz r31,20(r1)
ffc0ee5c: 38 21 00 18 addi r1,r1,24
ffc0ee60: 4e 80 00 20 blr
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
ffc0ee64: 3c 60 ff c2 lis r3,-62
ffc0ee68: 38 63 2e 58 addi r3,r3,11864
ffc0ee6c: 4c c6 31 82 crclr 4*cr1+eq
ffc0ee70: 4b ff 7f 99 bl ffc06e08 <printk>
ffc0ee74: 4b ff ff cc b ffc0ee40 <_Watchdog_Report_chain+0x88>
ffc0da94 <_Watchdog_Tickle>:
*/
void _Watchdog_Tickle(
Chain_Control *header
)
{
ffc0da94: 94 21 ff e8 stwu r1,-24(r1)
ffc0da98: 7c 08 02 a6 mflr r0
ffc0da9c: 90 01 00 1c stw r0,28(r1)
ffc0daa0: 93 e1 00 14 stw r31,20(r1)
ffc0daa4: 7c 7f 1b 78 mr r31,r3
ffc0daa8: 93 81 00 08 stw r28,8(r1)
ffc0daac: 93 a1 00 0c stw r29,12(r1)
ffc0dab0: 93 c1 00 10 stw r30,16(r1)
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0dab4: 7f 80 00 a6 mfmsr r28
ffc0dab8: 7c 10 42 a6 mfsprg r0,0
ffc0dabc: 7f 80 00 78 andc r0,r28,r0
ffc0dac0: 7c 00 01 24 mtmsr r0
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
ffc0dac4: 83 a3 00 00 lwz r29,0(r3)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
ffc0dac8: 3b c3 00 04 addi r30,r3,4
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
ffc0dacc: 7f 9d f0 00 cmpw cr7,r29,r30
ffc0dad0: 41 9e 00 20 beq- cr7,ffc0daf0 <_Watchdog_Tickle+0x5c>
* 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) {
ffc0dad4: 81 3d 00 10 lwz r9,16(r29)
ffc0dad8: 2f 89 00 00 cmpwi cr7,r9,0
ffc0dadc: 41 9e 00 74 beq- cr7,ffc0db50 <_Watchdog_Tickle+0xbc>
the_watchdog->delta_interval--;
ffc0dae0: 39 29 ff ff addi r9,r9,-1
if ( the_watchdog->delta_interval != 0 )
ffc0dae4: 2f 89 00 00 cmpwi cr7,r9,0
* 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) {
the_watchdog->delta_interval--;
ffc0dae8: 91 3d 00 10 stw r9,16(r29)
if ( the_watchdog->delta_interval != 0 )
ffc0daec: 41 be 00 64 beq+ cr7,ffc0db50 <_Watchdog_Tickle+0xbc>
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0daf0: 7f 80 01 24 mtmsr r28
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
ffc0daf4: 80 01 00 1c lwz r0,28(r1)
ffc0daf8: 83 81 00 08 lwz r28,8(r1)
ffc0dafc: 7c 08 03 a6 mtlr r0
ffc0db00: 83 a1 00 0c lwz r29,12(r1)
ffc0db04: 83 c1 00 10 lwz r30,16(r1)
ffc0db08: 83 e1 00 14 lwz r31,20(r1)
ffc0db0c: 38 21 00 18 addi r1,r1,24
ffc0db10: 4e 80 00 20 blr
_ISR_Enable( level );
switch( watchdog_state ) {
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
ffc0db14: 80 1d 00 1c lwz r0,28(r29)
ffc0db18: 80 7d 00 20 lwz r3,32(r29)
ffc0db1c: 80 9d 00 24 lwz r4,36(r29)
ffc0db20: 7c 09 03 a6 mtctr r0
ffc0db24: 4e 80 04 21 bctrl
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0db28: 7f 80 00 a6 mfmsr r28
ffc0db2c: 7c 10 42 a6 mfsprg r0,0
ffc0db30: 7f 80 00 78 andc r0,r28,r0
ffc0db34: 7c 00 01 24 mtmsr r0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc0db38: 83 bf 00 00 lwz r29,0(r31)
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
ffc0db3c: 7f 9e e8 00 cmpw cr7,r30,r29
ffc0db40: 41 be ff b0 beq- cr7,ffc0daf0 <_Watchdog_Tickle+0x5c>
}
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
ffc0db44: 80 1d 00 10 lwz r0,16(r29)
ffc0db48: 2f 80 00 00 cmpwi cr7,r0,0
ffc0db4c: 40 be ff a4 bne- cr7,ffc0daf0 <_Watchdog_Tickle+0x5c>
if ( the_watchdog->delta_interval != 0 )
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
ffc0db50: 7f a3 eb 78 mr r3,r29
ffc0db54: 4b ff fe 71 bl ffc0d9c4 <_Watchdog_Remove>
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0db58: 7f 80 01 24 mtmsr r28
_ISR_Enable( level );
switch( watchdog_state ) {
ffc0db5c: 2f 83 00 02 cmpwi cr7,r3,2
ffc0db60: 40 9e ff c8 bne+ cr7,ffc0db28 <_Watchdog_Tickle+0x94> <== NEVER TAKEN
ffc0db64: 4b ff ff b0 b ffc0db14 <_Watchdog_Tickle+0x80>
ffc186a4 <_fat_block_read>:
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
ffc186a4: 94 21 ff c8 stwu r1,-56(r1)
ffc186a8: 7c 08 02 a6 mflr r0
ffc186ac: 93 e1 00 34 stw r31,52(r1)
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while (count > 0)
ffc186b0: 7c df 33 79 mr. r31,r6
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
ffc186b4: 90 01 00 3c stw r0,60(r1)
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
ssize_t cmpltd = 0;
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
ffc186b8: 38 00 00 00 li r0,0
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
ffc186bc: 93 41 00 20 stw r26,32(r1)
ffc186c0: 7c fa 3b 78 mr r26,r7
ffc186c4: 93 61 00 24 stw r27,36(r1)
ffc186c8: 93 c1 00 30 stw r30,48(r1)
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
ssize_t cmpltd = 0;
ffc186cc: 3b c0 00 00 li r30,0
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
ffc186d0: 93 21 00 1c stw r25,28(r1)
ffc186d4: 93 81 00 28 stw r28,40(r1)
ffc186d8: 93 a1 00 2c stw r29,44(r1)
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc186dc: 83 63 00 34 lwz r27,52(r3)
ssize_t cmpltd = 0;
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
ffc186e0: 90 01 00 08 stw r0,8(r1)
uint32_t c = 0;
while (count > 0)
ffc186e4: 41 82 00 70 beq- ffc18754 <_fat_block_read+0xb0> <== NEVER TAKEN
ffc186e8: 7c bc 2b 78 mr r28,r5
ffc186ec: 7c 9d 23 78 mr r29,r4
ffc186f0: 48 00 00 3c b ffc1872c <_fat_block_read+0x88>
{
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
ffc186f4: a3 3b 00 00 lhz r25,0(r27)
memcpy((buff + cmpltd), (block->buffer + ofs), c);
ffc186f8: 81 21 00 08 lwz r9,8(r1)
{
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
ffc186fc: 7f 3c c8 50 subf r25,r28,r25
ffc18700: 7f 99 f8 40 cmplw cr7,r25,r31
ffc18704: 40 9d 00 08 ble- cr7,ffc1870c <_fat_block_read+0x68>
ffc18708: 7f f9 fb 78 mr r25,r31
memcpy((buff + cmpltd), (block->buffer + ofs), c);
ffc1870c: 80 89 00 24 lwz r4,36(r9)
ffc18710: 7f 25 cb 78 mr r5,r25
count -= c;
cmpltd += c;
ffc18714: 7f d9 f2 14 add r30,r25,r30
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
memcpy((buff + cmpltd), (block->buffer + ofs), c);
ffc18718: 7c 84 e2 14 add r4,r4,r28
ffc1871c: 48 00 c9 29 bl ffc25044 <memcpy>
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while (count > 0)
ffc18720: 7f f9 f8 51 subf. r31,r25,r31
memcpy((buff + cmpltd), (block->buffer + ofs), c);
count -= c;
cmpltd += c;
blk++;
ofs = 0;
ffc18724: 3b 80 00 00 li r28,0
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while (count > 0)
ffc18728: 41 82 00 2c beq- ffc18754 <_fat_block_read+0xb0>
{
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
ffc1872c: 7f a4 eb 78 mr r4,r29
ffc18730: 38 a0 00 01 li r5,1
ffc18734: 38 c1 00 08 addi r6,r1,8
ffc18738: 7f 63 db 78 mr r3,r27
ffc1873c: 4b ff fb 7d bl ffc182b8 <fat_buf_access>
c = MIN(count, (fs_info->vol.bps - ofs));
memcpy((buff + cmpltd), (block->buffer + ofs), c);
count -= c;
cmpltd += c;
blk++;
ffc18740: 3b bd 00 01 addi r29,r29,1
uint32_t c = 0;
while (count > 0)
{
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
ffc18744: 2f 83 00 00 cmpwi cr7,r3,0
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
memcpy((buff + cmpltd), (block->buffer + ofs), c);
ffc18748: 7c 7a f2 14 add r3,r26,r30
uint32_t c = 0;
while (count > 0)
{
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
ffc1874c: 41 9e ff a8 beq+ cr7,ffc186f4 <_fat_block_read+0x50> <== ALWAYS TAKEN
return -1;
ffc18750: 3b c0 ff ff li r30,-1 <== NOT EXECUTED
cmpltd += c;
blk++;
ofs = 0;
}
return cmpltd;
}
ffc18754: 80 01 00 3c lwz r0,60(r1)
ffc18758: 7f c3 f3 78 mr r3,r30
ffc1875c: 83 21 00 1c lwz r25,28(r1)
ffc18760: 7c 08 03 a6 mtlr r0
ffc18764: 83 41 00 20 lwz r26,32(r1)
ffc18768: 83 61 00 24 lwz r27,36(r1)
ffc1876c: 83 81 00 28 lwz r28,40(r1)
ffc18770: 83 a1 00 2c lwz r29,44(r1)
ffc18774: 83 c1 00 30 lwz r30,48(r1)
ffc18778: 83 e1 00 34 lwz r31,52(r1)
ffc1877c: 38 21 00 38 addi r1,r1,56
ffc18780: 4e 80 00 20 blr
ffc188a8 <_fat_block_release>:
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
ffc188a8: 80 63 00 34 lwz r3,52(r3) <== NOT EXECUTED
ffc188ac: 4b ff fc 54 b ffc18500 <fat_buf_release> <== NOT EXECUTED
ffc18784 <_fat_block_write>:
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
ffc18784: 94 21 ff c8 stwu r1,-56(r1)
ffc18788: 7c 08 02 a6 mflr r0
ffc1878c: 93 e1 00 34 stw r31,52(r1)
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while(count > 0)
ffc18790: 7c df 33 79 mr. r31,r6
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
ffc18794: 90 01 00 3c stw r0,60(r1)
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ssize_t cmpltd = 0;
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
ffc18798: 38 00 00 00 li r0,0
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
ffc1879c: 93 21 00 1c stw r25,28(r1)
ffc187a0: 7c f9 3b 78 mr r25,r7
ffc187a4: 93 61 00 24 stw r27,36(r1)
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ssize_t cmpltd = 0;
ffc187a8: 3b 60 00 00 li r27,0
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
ffc187ac: 93 81 00 28 stw r28,40(r1)
ffc187b0: 93 01 00 18 stw r24,24(r1)
ffc187b4: 93 41 00 20 stw r26,32(r1)
ffc187b8: 93 a1 00 2c stw r29,44(r1)
ffc187bc: 93 c1 00 30 stw r30,48(r1)
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc187c0: 83 83 00 34 lwz r28,52(r3)
ssize_t cmpltd = 0;
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
ffc187c4: 90 01 00 08 stw r0,8(r1)
uint32_t c = 0;
while(count > 0)
ffc187c8: 41 82 00 ac beq- ffc18874 <_fat_block_write+0xf0> <== NEVER TAKEN
ffc187cc: 7c ba 2b 78 mr r26,r5
ffc187d0: 7c 9d 23 78 mr r29,r4
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
ffc187d4: 3b 00 00 01 li r24,1
ffc187d8: 48 00 00 40 b ffc18818 <_fat_block_write+0x94>
c = MIN(count, (fs_info->vol.bps - ofs));
if (c == fs_info->vol.bps)
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_GET, &block);
else
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
ffc187dc: 4b ff fa dd bl ffc182b8 <fat_buf_access>
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
blk++;
ffc187e0: 3b bd 00 01 addi r29,r29,1
if (c == fs_info->vol.bps)
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_GET, &block);
else
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
ffc187e4: 2f 83 00 00 cmpwi cr7,r3,0
return -1;
memcpy((block->buffer + ofs), (buff + cmpltd), c);
ffc187e8: 7c 99 da 14 add r4,r25,r27
ffc187ec: 7f c5 f3 78 mr r5,r30
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
ffc187f0: 7f 7e da 14 add r27,r30,r27
if (c == fs_info->vol.bps)
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_GET, &block);
else
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
ffc187f4: 40 9e 00 7c bne- cr7,ffc18870 <_fat_block_write+0xec> <== NEVER TAKEN
return -1;
memcpy((block->buffer + ofs), (buff + cmpltd), c);
ffc187f8: 81 21 00 08 lwz r9,8(r1)
ffc187fc: 80 69 00 24 lwz r3,36(r9)
ffc18800: 7c 63 d2 14 add r3,r3,r26
ffc18804: 48 00 c8 41 bl ffc25044 <memcpy>
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while(count > 0)
ffc18808: 7f fe f8 51 subf. r31,r30,r31
ffc1880c: 9b 1c 00 84 stb r24,132(r28)
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
blk++;
ofs = 0;
ffc18810: 3b 40 00 00 li r26,0
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while(count > 0)
ffc18814: 41 82 00 60 beq- ffc18874 <_fat_block_write+0xf0>
{
c = MIN(count, (fs_info->vol.bps - ofs));
ffc18818: a0 1c 00 00 lhz r0,0(r28)
if (c == fs_info->vol.bps)
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_GET, &block);
else
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
ffc1881c: 7f a4 eb 78 mr r4,r29
ffc18820: 38 a0 00 01 li r5,1
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while(count > 0)
{
c = MIN(count, (fs_info->vol.bps - ofs));
ffc18824: 7f da 00 50 subf r30,r26,r0
ffc18828: 7f 9e f8 40 cmplw cr7,r30,r31
if (c == fs_info->vol.bps)
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_GET, &block);
else
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
ffc1882c: 38 c1 00 08 addi r6,r1,8
ffc18830: 7f 83 e3 78 mr r3,r28
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while(count > 0)
{
c = MIN(count, (fs_info->vol.bps - ofs));
ffc18834: 40 9d 00 08 ble- cr7,ffc1883c <_fat_block_write+0xb8>
ffc18838: 7f fe fb 78 mr r30,r31
if (c == fs_info->vol.bps)
ffc1883c: 7f 80 f0 00 cmpw cr7,r0,r30
ffc18840: 40 9e ff 9c bne+ cr7,ffc187dc <_fat_block_write+0x58>
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_GET, &block);
ffc18844: 7f a4 eb 78 mr r4,r29
ffc18848: 38 a0 00 02 li r5,2
ffc1884c: 7f 83 e3 78 mr r3,r28
ffc18850: 38 c1 00 08 addi r6,r1,8
ffc18854: 4b ff fa 65 bl ffc182b8 <fat_buf_access>
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
blk++;
ffc18858: 3b bd 00 01 addi r29,r29,1
if (c == fs_info->vol.bps)
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_GET, &block);
else
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
ffc1885c: 2f 83 00 00 cmpwi cr7,r3,0
return -1;
memcpy((block->buffer + ofs), (buff + cmpltd), c);
ffc18860: 7c 99 da 14 add r4,r25,r27
ffc18864: 7f c5 f3 78 mr r5,r30
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
ffc18868: 7f 7e da 14 add r27,r30,r27
if (c == fs_info->vol.bps)
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_GET, &block);
else
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
ffc1886c: 41 9e ff 8c beq+ cr7,ffc187f8 <_fat_block_write+0x74> <== ALWAYS TAKEN
return -1;
ffc18870: 3b 60 ff ff li r27,-1 <== NOT EXECUTED
cmpltd +=c;
blk++;
ofs = 0;
}
return cmpltd;
}
ffc18874: 80 01 00 3c lwz r0,60(r1)
ffc18878: 7f 63 db 78 mr r3,r27
ffc1887c: 83 01 00 18 lwz r24,24(r1)
ffc18880: 7c 08 03 a6 mtlr r0
ffc18884: 83 21 00 1c lwz r25,28(r1)
ffc18888: 83 41 00 20 lwz r26,32(r1)
ffc1888c: 83 61 00 24 lwz r27,36(r1)
ffc18890: 83 81 00 28 lwz r28,40(r1)
ffc18894: 83 a1 00 2c lwz r29,44(r1)
ffc18898: 83 c1 00 30 lwz r30,48(r1)
ffc1889c: 83 e1 00 34 lwz r31,52(r1)
ffc188a0: 38 21 00 38 addi r1,r1,56
ffc188a4: 4e 80 00 20 blr
ffc25764 <_rename_r>:
int _rename_r(
struct _reent *ptr __attribute__((unused)),
const char *old,
const char *new
)
{
ffc25764: 94 21 ff 90 stwu r1,-112(r1)
ffc25768: 7c 08 02 a6 mflr r0
/*
* Get the parent node of the old path to be renamed. Find the parent path.
*/
old_parent_pathlen = rtems_filesystem_dirname ( old );
ffc2576c: 7c 83 23 78 mr r3,r4
int _rename_r(
struct _reent *ptr __attribute__((unused)),
const char *old,
const char *new
)
{
ffc25770: 93 61 00 5c stw r27,92(r1)
ffc25774: 7c bb 2b 78 mr r27,r5
ffc25778: 93 a1 00 64 stw r29,100(r1)
ffc2577c: 93 c1 00 68 stw r30,104(r1)
*/
old_parent_pathlen = rtems_filesystem_dirname ( old );
if ( old_parent_pathlen == 0 )
rtems_filesystem_get_start_loc( old, &i, &old_parent_loc );
ffc25780: 3b c1 00 24 addi r30,r1,36
int _rename_r(
struct _reent *ptr __attribute__((unused)),
const char *old,
const char *new
)
{
ffc25784: 93 e1 00 6c stw r31,108(r1)
ffc25788: 7c 9f 23 78 mr r31,r4
ffc2578c: 90 01 00 74 stw r0,116(r1)
ffc25790: 93 41 00 58 stw r26,88(r1)
ffc25794: 93 81 00 60 stw r28,96(r1)
/*
* Get the parent node of the old path to be renamed. Find the parent path.
*/
old_parent_pathlen = rtems_filesystem_dirname ( old );
ffc25798: 4b fe 1a d1 bl ffc07268 <rtems_filesystem_dirname>
if ( old_parent_pathlen == 0 )
ffc2579c: 7c 7d 1b 79 mr. r29,r3
rtems_filesystem_get_start_loc( old, &i, &old_parent_loc );
ffc257a0: 7f e3 fb 78 mr r3,r31
* Get the parent node of the old path to be renamed. Find the parent path.
*/
old_parent_pathlen = rtems_filesystem_dirname ( old );
if ( old_parent_pathlen == 0 )
ffc257a4: 40 82 00 c4 bne- ffc25868 <_rename_r+0x104>
rtems_filesystem_get_start_loc( old, &i, &old_parent_loc );
ffc257a8: 38 81 00 0c addi r4,r1,12
ffc257ac: 7f c5 f3 78 mr r5,r30
ffc257b0: 4b fe 39 d9 bl ffc09188 <rtems_filesystem_get_start_loc>
ffc257b4: 3b a0 00 00 li r29,0
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;
ffc257b8: 3b 80 00 00 li r28,0
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
ffc257bc: 80 01 00 24 lwz r0,36(r1)
name = old + old_parent_pathlen;
ffc257c0: 7f ff ea 14 add r31,r31,r29
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
ffc257c4: 7f e3 fb 78 mr r3,r31
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
name = old + old_parent_pathlen;
ffc257c8: 93 e1 00 08 stw r31,8(r1)
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
ffc257cc: 90 01 00 38 stw r0,56(r1)
ffc257d0: 80 01 00 28 lwz r0,40(r1)
ffc257d4: 90 01 00 3c stw r0,60(r1)
ffc257d8: 80 01 00 2c lwz r0,44(r1)
ffc257dc: 90 01 00 40 stw r0,64(r1)
ffc257e0: 80 01 00 30 lwz r0,48(r1)
ffc257e4: 90 01 00 44 stw r0,68(r1)
ffc257e8: 80 01 00 34 lwz r0,52(r1)
ffc257ec: 90 01 00 48 stw r0,72(r1)
name = old + old_parent_pathlen;
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
ffc257f0: 4b ff 2a 89 bl ffc18278 <strlen>
ffc257f4: 7c 64 1b 78 mr r4,r3
ffc257f8: 7f e3 fb 78 mr r3,r31
ffc257fc: 4b fe 1a cd bl ffc072c8 <rtems_filesystem_prefix_separators>
ffc25800: 7f ff 1a 14 add r31,r31,r3
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
ffc25804: 7f e3 fb 78 mr r3,r31
* 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 ) );
ffc25808: 93 e1 00 08 stw r31,8(r1)
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
ffc2580c: 4b ff 2a 6d bl ffc18278 <strlen>
ffc25810: 38 a0 00 00 li r5,0
ffc25814: 7c 64 1b 78 mr r4,r3
ffc25818: 38 c1 00 38 addi r6,r1,56
ffc2581c: 7f e3 fb 78 mr r3,r31
ffc25820: 38 e0 00 00 li r7,0
ffc25824: 4b fe 19 1d bl ffc07140 <rtems_filesystem_evaluate_relative_path>
0, &old_loc, false );
if ( result != 0 ) {
ffc25828: 2f 83 00 00 cmpwi cr7,r3,0
ffc2582c: 41 9e 00 98 beq- cr7,ffc258c4 <_rename_r+0x160>
if ( free_old_parentloc )
ffc25830: 2f 9c 00 00 cmpwi cr7,r28,0
rtems_filesystem_freenode( &old_parent_loc );
return -1;
ffc25834: 3b 40 ff ff li r26,-1
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 )
ffc25838: 40 9e 00 58 bne- cr7,ffc25890 <_rename_r+0x12c>
if ( free_old_parentloc )
rtems_filesystem_freenode( &old_parent_loc );
rtems_filesystem_freenode( &old_loc );
return result;
}
ffc2583c: 80 01 00 74 lwz r0,116(r1)
ffc25840: 7f 43 d3 78 mr r3,r26
ffc25844: 83 61 00 5c lwz r27,92(r1)
ffc25848: 7c 08 03 a6 mtlr r0
ffc2584c: 83 41 00 58 lwz r26,88(r1)
ffc25850: 83 81 00 60 lwz r28,96(r1)
ffc25854: 83 a1 00 64 lwz r29,100(r1)
ffc25858: 83 c1 00 68 lwz r30,104(r1)
ffc2585c: 83 e1 00 6c lwz r31,108(r1)
ffc25860: 38 21 00 70 addi r1,r1,112
ffc25864: 4e 80 00 20 blr
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,
ffc25868: 7f a4 eb 78 mr r4,r29
ffc2586c: 38 a0 00 02 li r5,2
ffc25870: 7f c6 f3 78 mr r6,r30
ffc25874: 38 e0 00 00 li r7,0
ffc25878: 4b fe 19 75 bl ffc071ec <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&old_parent_loc,
false );
if ( result != 0 )
return -1;
ffc2587c: 3b 40 ff ff li r26,-1
else {
result = rtems_filesystem_evaluate_path( old, old_parent_pathlen,
RTEMS_LIBIO_PERMS_WRITE,
&old_parent_loc,
false );
if ( result != 0 )
ffc25880: 2f 83 00 00 cmpwi cr7,r3,0
ffc25884: 40 be ff b8 bne- cr7,ffc2583c <_rename_r+0xd8> <== NEVER TAKEN
return -1;
free_old_parentloc = true;
ffc25888: 3b 80 00 01 li r28,1
ffc2588c: 4b ff ff 30 b ffc257bc <_rename_r+0x58>
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 );
ffc25890: 7f c3 f3 78 mr r3,r30
ffc25894: 4b fe 1c 39 bl ffc074cc <rtems_filesystem_freenode>
if ( free_old_parentloc )
rtems_filesystem_freenode( &old_parent_loc );
rtems_filesystem_freenode( &old_loc );
return result;
}
ffc25898: 80 01 00 74 lwz r0,116(r1)
ffc2589c: 7f 43 d3 78 mr r3,r26
ffc258a0: 83 61 00 5c lwz r27,92(r1)
ffc258a4: 7c 08 03 a6 mtlr r0
ffc258a8: 83 41 00 58 lwz r26,88(r1)
ffc258ac: 83 81 00 60 lwz r28,96(r1)
ffc258b0: 83 a1 00 64 lwz r29,100(r1)
ffc258b4: 83 c1 00 68 lwz r30,104(r1)
ffc258b8: 83 e1 00 6c lwz r31,108(r1)
ffc258bc: 38 21 00 70 addi r1,r1,112
ffc258c0: 4e 80 00 20 blr
/*
* Get the parent of the new node we are renaming to.
*/
rtems_filesystem_get_start_loc( new, &i, &new_parent_loc );
ffc258c4: 7f 63 db 78 mr r3,r27
ffc258c8: 38 81 00 0c addi r4,r1,12
ffc258cc: 38 a1 00 10 addi r5,r1,16
ffc258d0: 4b fe 38 b9 bl ffc09188 <rtems_filesystem_get_start_loc>
result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name );
ffc258d4: 81 21 00 1c lwz r9,28(r1)
ffc258d8: 80 61 00 0c lwz r3,12(r1)
ffc258dc: 38 81 00 10 addi r4,r1,16
ffc258e0: 80 09 00 04 lwz r0,4(r9)
ffc258e4: 38 a1 00 08 addi r5,r1,8
ffc258e8: 7c 7b 1a 14 add r3,r27,r3
ffc258ec: 7c 09 03 a6 mtctr r0
ffc258f0: 4e 80 04 21 bctrl
if ( result != 0 ) {
ffc258f4: 2f 83 00 00 cmpwi cr7,r3,0
ffc258f8: 40 9e 00 c0 bne- cr7,ffc259b8 <_rename_r+0x254>
/*
* 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 ) {
ffc258fc: 80 01 00 20 lwz r0,32(r1)
ffc25900: 81 21 00 34 lwz r9,52(r1)
ffc25904: 7f 89 00 00 cmpw cr7,r9,r0
ffc25908: 40 9e 00 78 bne- cr7,ffc25980 <_rename_r+0x21c>
rtems_filesystem_freenode( &old_parent_loc );
rtems_filesystem_freenode( &old_loc );
rtems_set_errno_and_return_minus_one( EXDEV );
}
result = (*new_parent_loc.ops->rename_h)( &old_parent_loc, &old_loc, &new_parent_loc, name );
ffc2590c: 81 21 00 1c lwz r9,28(r1)
ffc25910: 38 81 00 38 addi r4,r1,56
ffc25914: 38 a1 00 10 addi r5,r1,16
ffc25918: 80 c1 00 08 lwz r6,8(r1)
ffc2591c: 80 09 00 40 lwz r0,64(r9)
ffc25920: 7f c3 f3 78 mr r3,r30
ffc25924: 7c 09 03 a6 mtctr r0
ffc25928: 4e 80 04 21 bctrl
ffc2592c: 7c 7a 1b 78 mr r26,r3
rtems_filesystem_freenode( &new_parent_loc );
ffc25930: 38 61 00 10 addi r3,r1,16
ffc25934: 4b fe 1b 99 bl ffc074cc <rtems_filesystem_freenode>
if ( free_old_parentloc )
ffc25938: 2f 9c 00 00 cmpwi cr7,r28,0
ffc2593c: 40 9e 00 38 bne- cr7,ffc25974 <_rename_r+0x210>
rtems_filesystem_freenode( &old_parent_loc );
rtems_filesystem_freenode( &old_loc );
ffc25940: 38 61 00 38 addi r3,r1,56
ffc25944: 4b fe 1b 89 bl ffc074cc <rtems_filesystem_freenode>
return result;
}
ffc25948: 80 01 00 74 lwz r0,116(r1)
ffc2594c: 7f 43 d3 78 mr r3,r26
ffc25950: 83 61 00 5c lwz r27,92(r1)
ffc25954: 7c 08 03 a6 mtlr r0
ffc25958: 83 41 00 58 lwz r26,88(r1)
ffc2595c: 83 81 00 60 lwz r28,96(r1)
ffc25960: 83 a1 00 64 lwz r29,100(r1)
ffc25964: 83 c1 00 68 lwz r30,104(r1)
ffc25968: 83 e1 00 6c lwz r31,108(r1)
ffc2596c: 38 21 00 70 addi r1,r1,112
ffc25970: 4e 80 00 20 blr
result = (*new_parent_loc.ops->rename_h)( &old_parent_loc, &old_loc, &new_parent_loc, name );
rtems_filesystem_freenode( &new_parent_loc );
if ( free_old_parentloc )
rtems_filesystem_freenode( &old_parent_loc );
ffc25974: 7f c3 f3 78 mr r3,r30
ffc25978: 4b fe 1b 55 bl ffc074cc <rtems_filesystem_freenode>
ffc2597c: 4b ff ff c4 b ffc25940 <_rename_r+0x1dc>
* Check to see if the caller is trying to rename across file system
* boundaries.
*/
if ( old_parent_loc.mt_entry != new_parent_loc.mt_entry ) {
rtems_filesystem_freenode( &new_parent_loc );
ffc25980: 38 61 00 10 addi r3,r1,16
ffc25984: 4b fe 1b 49 bl ffc074cc <rtems_filesystem_freenode>
if ( free_old_parentloc )
ffc25988: 2f 9c 00 00 cmpwi cr7,r28,0
ffc2598c: 40 9e 00 20 bne- cr7,ffc259ac <_rename_r+0x248>
rtems_filesystem_freenode( &old_parent_loc );
rtems_filesystem_freenode( &old_loc );
ffc25990: 38 61 00 38 addi r3,r1,56
ffc25994: 4b fe 1b 39 bl ffc074cc <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EXDEV );
ffc25998: 3b 40 ff ff li r26,-1
ffc2599c: 4b ff 10 91 bl ffc16a2c <__errno>
ffc259a0: 38 00 00 12 li r0,18
ffc259a4: 90 03 00 00 stw r0,0(r3)
ffc259a8: 4b ff fe 94 b ffc2583c <_rename_r+0xd8>
*/
if ( old_parent_loc.mt_entry != new_parent_loc.mt_entry ) {
rtems_filesystem_freenode( &new_parent_loc );
if ( free_old_parentloc )
rtems_filesystem_freenode( &old_parent_loc );
ffc259ac: 7f c3 f3 78 mr r3,r30
ffc259b0: 4b fe 1b 1d bl ffc074cc <rtems_filesystem_freenode>
ffc259b4: 4b ff ff dc b ffc25990 <_rename_r+0x22c>
rtems_filesystem_get_start_loc( new, &i, &new_parent_loc );
result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name );
if ( result != 0 ) {
rtems_filesystem_freenode( &new_parent_loc );
ffc259b8: 38 61 00 10 addi r3,r1,16
ffc259bc: 4b fe 1b 11 bl ffc074cc <rtems_filesystem_freenode>
if ( free_old_parentloc )
ffc259c0: 2f 9c 00 00 cmpwi cr7,r28,0
ffc259c4: 41 be 00 0c beq+ cr7,ffc259d0 <_rename_r+0x26c>
rtems_filesystem_freenode( &old_parent_loc );
ffc259c8: 7f c3 f3 78 mr r3,r30
ffc259cc: 4b fe 1b 01 bl ffc074cc <rtems_filesystem_freenode>
rtems_filesystem_freenode( &old_loc );
ffc259d0: 38 61 00 38 addi r3,r1,56
ffc259d4: 4b fe 1a f9 bl ffc074cc <rtems_filesystem_freenode>
return -1;
ffc259d8: 3b 40 ff ff li r26,-1
ffc259dc: 4b ff fe 60 b ffc2583c <_rename_r+0xd8>
ffc08da8 <adjtime>:
int adjtime(
struct timeval *delta,
struct timeval *olddelta
)
{
ffc08da8: 94 21 ff d8 stwu r1,-40(r1)
ffc08dac: 7d 80 00 26 mfcr r12
ffc08db0: 7c 08 02 a6 mflr r0
ffc08db4: 93 e1 00 24 stw r31,36(r1)
long adjustment;
/*
* Simple validations
*/
if ( !delta )
ffc08db8: 7c 7f 1b 79 mr. r31,r3
int adjtime(
struct timeval *delta,
struct timeval *olddelta
)
{
ffc08dbc: 93 c1 00 20 stw r30,32(r1)
ffc08dc0: 7c 9e 23 78 mr r30,r4
ffc08dc4: 90 01 00 2c stw r0,44(r1)
ffc08dc8: 91 81 00 1c stw r12,28(r1)
long adjustment;
/*
* Simple validations
*/
if ( !delta )
ffc08dcc: 41 82 01 70 beq- ffc08f3c <adjtime+0x194>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )
ffc08dd0: 81 3f 00 04 lwz r9,4(r31)
ffc08dd4: 3c 00 00 0f lis r0,15
ffc08dd8: 60 00 42 3f ori r0,r0,16959
ffc08ddc: 7f 89 00 40 cmplw cr7,r9,r0
ffc08de0: 41 9d 01 5c bgt- cr7,ffc08f3c <adjtime+0x194>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( olddelta ) {
ffc08de4: 2e 04 00 00 cmpwi cr4,r4,0
ffc08de8: 41 92 00 14 beq- cr4,ffc08dfc <adjtime+0x54>
olddelta->tv_sec = 0;
ffc08dec: 38 00 00 00 li r0,0
olddelta->tv_usec = 0;
ffc08df0: 90 04 00 04 stw r0,4(r4)
if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( olddelta ) {
olddelta->tv_sec = 0;
ffc08df4: 90 04 00 00 stw r0,0(r4)
olddelta->tv_usec = 0;
ffc08df8: 81 3f 00 04 lwz r9,4(r31)
}
/* convert delta to microseconds */
adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);
ffc08dfc: 80 1f 00 00 lwz r0,0(r31)
adjustment += delta->tv_usec;
/* too small to account for */
if ( adjustment < rtems_configuration_get_microseconds_per_tick() )
return 0;
ffc08e00: 38 60 00 00 li r3,0
olddelta->tv_sec = 0;
olddelta->tv_usec = 0;
}
/* convert delta to microseconds */
adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);
ffc08e04: 54 0a 40 2e rlwinm r10,r0,8,0,23
ffc08e08: 54 0b 18 38 rlwinm r11,r0,3,0,28
ffc08e0c: 7d 6b 50 50 subf r11,r11,r10
ffc08e10: 55 6a 30 32 rlwinm r10,r11,6,0,25
ffc08e14: 7d 6b 50 50 subf r11,r11,r10
ffc08e18: 7c 0b 02 14 add r0,r11,r0
adjustment += delta->tv_usec;
/* too small to account for */
if ( adjustment < rtems_configuration_get_microseconds_per_tick() )
ffc08e1c: 3d 60 00 00 lis r11,0
olddelta->tv_sec = 0;
olddelta->tv_usec = 0;
}
/* convert delta to microseconds */
adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);
ffc08e20: 54 00 30 32 rlwinm r0,r0,6,0,25
adjustment += delta->tv_usec;
/* too small to account for */
if ( adjustment < rtems_configuration_get_microseconds_per_tick() )
ffc08e24: 81 4b 20 10 lwz r10,8208(r11)
olddelta->tv_usec = 0;
}
/* convert delta to microseconds */
adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);
adjustment += delta->tv_usec;
ffc08e28: 7d 20 4a 14 add r9,r0,r9
/* too small to account for */
if ( adjustment < rtems_configuration_get_microseconds_per_tick() )
ffc08e2c: 7f 89 50 40 cmplw cr7,r9,r10
ffc08e30: 40 9c 00 24 bge- cr7,ffc08e54 <adjtime+0xac>
/* set the user's output */
if ( olddelta )
*olddelta = *delta;
return 0;
}
ffc08e34: 80 01 00 2c lwz r0,44(r1)
ffc08e38: 81 81 00 1c lwz r12,28(r1)
ffc08e3c: 7c 08 03 a6 mtlr r0
ffc08e40: 83 c1 00 20 lwz r30,32(r1)
ffc08e44: 83 e1 00 24 lwz r31,36(r1)
ffc08e48: 7d 80 81 20 mtcrf 8,r12
ffc08e4c: 38 21 00 28 addi r1,r1,40
ffc08e50: 4e 80 00 20 blr
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc08e54: 3d 20 00 00 lis r9,0
ffc08e58: 81 69 29 28 lwz r11,10536(r9)
ffc08e5c: 38 0b 00 01 addi r0,r11,1
ffc08e60: 90 09 29 28 stw r0,10536(r9)
return _Thread_Dispatch_disable_level;
ffc08e64: 80 09 29 28 lwz r0,10536(r9)
* This prevents context switches while we are adjusting the TOD
*/
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ffc08e68: 38 61 00 08 addi r3,r1,8
ffc08e6c: 48 00 1f 6d bl ffc0add8 <_TOD_Get>
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
ffc08e70: 81 3f 00 04 lwz r9,4(r31)
ffc08e74: 80 01 00 0c lwz r0,12(r1)
ffc08e78: 1d 29 03 e8 mulli r9,r9,1000
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
ffc08e7c: 81 41 00 08 lwz r10,8(r1)
ffc08e80: 81 7f 00 00 lwz r11,0(r31)
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
ffc08e84: 7d 29 02 14 add r9,r9,r0
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
ffc08e88: 3c 00 3b 9a lis r0,15258
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
ffc08e8c: 91 21 00 0c stw r9,12(r1)
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
ffc08e90: 60 00 c9 ff ori r0,r0,51711
ffc08e94: 7f 89 00 40 cmplw cr7,r9,r0
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
ffc08e98: 7d 6a 5a 14 add r11,r10,r11
ffc08e9c: 91 61 00 08 stw r11,8(r1)
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
ffc08ea0: 40 9d 00 20 ble- cr7,ffc08ec0 <adjtime+0x118>
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
ffc08ea4: 3d 29 c4 65 addis r9,r9,-15259
ffc08ea8: 39 29 36 00 addi r9,r9,13824
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
ffc08eac: 7f 89 00 40 cmplw cr7,r9,r0
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec++;
ffc08eb0: 39 6b 00 01 addi r11,r11,1
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
ffc08eb4: 41 9d ff f0 bgt+ cr7,ffc08ea4 <adjtime+0xfc> <== NEVER TAKEN
ffc08eb8: 91 21 00 0c stw r9,12(r1)
ffc08ebc: 91 61 00 08 stw r11,8(r1)
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec++;
}
/* if adjustment is too much negative */
while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) {
ffc08ec0: 3c 00 c4 65 lis r0,-15259
ffc08ec4: 60 00 36 00 ori r0,r0,13824
ffc08ec8: 7f 89 00 40 cmplw cr7,r9,r0
ffc08ecc: 41 9d 00 24 bgt- cr7,ffc08ef0 <adjtime+0x148> <== NEVER TAKEN
ffc08ed0: 81 61 00 08 lwz r11,8(r1)
ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;
ffc08ed4: 3d 29 3b 9b addis r9,r9,15259
ffc08ed8: 39 29 ca 00 addi r9,r9,-13824
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec++;
}
/* if adjustment is too much negative */
while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) {
ffc08edc: 7f 89 00 40 cmplw cr7,r9,r0
ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec--;
ffc08ee0: 39 6b ff ff addi r11,r11,-1
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec++;
}
/* if adjustment is too much negative */
while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) {
ffc08ee4: 40 9d ff f0 ble+ cr7,ffc08ed4 <adjtime+0x12c>
ffc08ee8: 91 21 00 0c stw r9,12(r1)
ffc08eec: 91 61 00 08 stw r11,8(r1)
ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec--;
}
_TOD_Set( &ts );
ffc08ef0: 38 61 00 08 addi r3,r1,8
ffc08ef4: 48 00 1f b5 bl ffc0aea8 <_TOD_Set>
_Thread_Enable_dispatch();
ffc08ef8: 48 00 3c e1 bl ffc0cbd8 <_Thread_Enable_dispatch>
/* set the user's output */
if ( olddelta )
ffc08efc: 41 92 00 38 beq- cr4,ffc08f34 <adjtime+0x18c>
*olddelta = *delta;
return 0;
}
ffc08f00: 80 01 00 2c lwz r0,44(r1)
/* set the user's output */
if ( olddelta )
*olddelta = *delta;
return 0;
ffc08f04: 38 60 00 00 li r3,0
_Thread_Enable_dispatch();
/* set the user's output */
if ( olddelta )
*olddelta = *delta;
ffc08f08: 81 5f 00 00 lwz r10,0(r31)
return 0;
}
ffc08f0c: 7c 08 03 a6 mtlr r0
_Thread_Enable_dispatch();
/* set the user's output */
if ( olddelta )
*olddelta = *delta;
ffc08f10: 81 7f 00 04 lwz r11,4(r31)
return 0;
}
ffc08f14: 81 81 00 1c lwz r12,28(r1)
_Thread_Enable_dispatch();
/* set the user's output */
if ( olddelta )
*olddelta = *delta;
ffc08f18: 91 5e 00 00 stw r10,0(r30)
return 0;
}
ffc08f1c: 7d 80 81 20 mtcrf 8,r12
_Thread_Enable_dispatch();
/* set the user's output */
if ( olddelta )
*olddelta = *delta;
ffc08f20: 91 7e 00 04 stw r11,4(r30)
return 0;
}
ffc08f24: 83 e1 00 24 lwz r31,36(r1)
ffc08f28: 83 c1 00 20 lwz r30,32(r1)
ffc08f2c: 38 21 00 28 addi r1,r1,40
ffc08f30: 4e 80 00 20 blr
/* set the user's output */
if ( olddelta )
*olddelta = *delta;
return 0;
ffc08f34: 38 60 00 00 li r3,0
ffc08f38: 4b ff fe fc b ffc08e34 <adjtime+0x8c>
*/
if ( !delta )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )
rtems_set_errno_and_return_minus_one( EINVAL );
ffc08f3c: 48 00 b5 ed bl ffc14528 <__errno>
ffc08f40: 38 00 00 16 li r0,22
ffc08f44: 90 03 00 00 stw r0,0(r3)
ffc08f48: 38 60 ff ff li r3,-1
ffc08f4c: 4b ff fe e8 b ffc08e34 <adjtime+0x8c>
ffc098b0 <aio_cancel>:
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
ffc098b0: 94 21 ff e8 stwu r1,-24(r1)
ffc098b4: 7c 08 02 a6 mflr r0
ffc098b8: 93 e1 00 14 stw r31,20(r1)
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
ffc098bc: 3f e0 00 00 lis r31,0
ffc098c0: 3b ff 2c 70 addi r31,r31,11376
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
ffc098c4: 93 a1 00 0c stw r29,12(r1)
ffc098c8: 7c 7d 1b 78 mr r29,r3
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
ffc098cc: 7f e3 fb 78 mr r3,r31
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
ffc098d0: 90 01 00 1c stw r0,28(r1)
ffc098d4: 93 c1 00 10 stw r30,16(r1)
ffc098d8: 7c 9e 23 78 mr r30,r4
ffc098dc: 93 81 00 08 stw r28,8(r1)
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
ffc098e0: 48 00 16 45 bl ffc0af24 <pthread_mutex_lock>
if (fcntl (fildes, F_GETFD) < 0) {
ffc098e4: 7f a3 eb 78 mr r3,r29
ffc098e8: 38 80 00 01 li r4,1
ffc098ec: 4c c6 31 82 crclr 4*cr1+eq
ffc098f0: 48 00 8f 75 bl ffc12864 <fcntl>
ffc098f4: 2f 83 00 00 cmpwi cr7,r3,0
ffc098f8: 41 9c 01 bc blt- cr7,ffc09ab4 <aio_cancel+0x204>
pthread_mutex_unlock(&aio_request_queue.mutex);
rtems_set_errno_and_return_minus_one (EBADF);
}
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
ffc098fc: 2f 9e 00 00 cmpwi cr7,r30,0
ffc09900: 41 9e 01 08 beq- cr7,ffc09a08 <aio_cancel+0x158>
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_CANCELED;
} else {
AIO_printf ("Cancel request\n");
if (aiocbp->aio_fildes != fildes) {
ffc09904: 83 9e 00 00 lwz r28,0(r30)
ffc09908: 7f 9c e8 00 cmpw cr7,r28,r29
ffc0990c: 40 9e 00 e0 bne- cr7,ffc099ec <aio_cancel+0x13c>
pthread_mutex_unlock (&aio_request_queue.mutex);
rtems_set_errno_and_return_minus_one (EINVAL);
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
ffc09910: 38 7f 00 48 addi r3,r31,72
ffc09914: 7f 84 e3 78 mr r4,r28
ffc09918: 38 a0 00 00 li r5,0
ffc0991c: 48 00 03 bd bl ffc09cd8 <rtems_aio_search_fd>
if (r_chain == NULL) {
ffc09920: 7c 7d 1b 79 mr. r29,r3
ffc09924: 41 82 00 54 beq- ffc09978 <aio_cancel+0xc8>
return AIO_ALLDONE;
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
ffc09928: 3b 9d 00 1c addi r28,r29,28
ffc0992c: 7f 83 e3 78 mr r3,r28
ffc09930: 48 00 15 f5 bl ffc0af24 <pthread_mutex_lock>
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
ffc09934: 7f c4 f3 78 mr r4,r30
ffc09938: 38 7d 00 08 addi r3,r29,8
ffc0993c: 48 00 09 19 bl ffc0a254 <rtems_aio_remove_req>
ffc09940: 7c 7e 1b 78 mr r30,r3
pthread_mutex_unlock (&r_chain->mutex);
ffc09944: 7f 83 e3 78 mr r3,r28
ffc09948: 48 00 16 a9 bl ffc0aff0 <pthread_mutex_unlock>
pthread_mutex_unlock (&aio_request_queue.mutex);
ffc0994c: 7f e3 fb 78 mr r3,r31
ffc09950: 48 00 16 a1 bl ffc0aff0 <pthread_mutex_unlock>
return result;
}
return AIO_ALLDONE;
}
ffc09954: 80 01 00 1c lwz r0,28(r1)
ffc09958: 7f c3 f3 78 mr r3,r30
ffc0995c: 83 81 00 08 lwz r28,8(r1)
ffc09960: 7c 08 03 a6 mtlr r0
ffc09964: 83 a1 00 0c lwz r29,12(r1)
ffc09968: 83 c1 00 10 lwz r30,16(r1)
ffc0996c: 83 e1 00 14 lwz r31,20(r1)
ffc09970: 38 21 00 18 addi r1,r1,24
ffc09974: 4e 80 00 20 blr
rtems_set_errno_and_return_minus_one (EINVAL);
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
if (r_chain == NULL) {
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
ffc09978: 81 3f 00 54 lwz r9,84(r31)
ffc0997c: 38 1f 00 58 addi r0,r31,88
ffc09980: 7f 89 00 00 cmpw cr7,r9,r0
ffc09984: 41 9e 00 58 beq- cr7,ffc099dc <aio_cancel+0x12c> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
ffc09988: 38 7f 00 54 addi r3,r31,84
ffc0998c: 7f 84 e3 78 mr r4,r28
ffc09990: 38 a0 00 00 li r5,0
ffc09994: 48 00 03 45 bl ffc09cd8 <rtems_aio_search_fd>
if (r_chain == NULL) {
ffc09998: 2c 03 00 00 cmpwi r3,0
ffc0999c: 41 82 00 50 beq- ffc099ec <aio_cancel+0x13c>
rtems_set_errno_and_return_minus_one (EINVAL);
}
AIO_printf ("Request on [IQ]\n");
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
ffc099a0: 7f c4 f3 78 mr r4,r30
ffc099a4: 38 63 00 08 addi r3,r3,8
ffc099a8: 48 00 08 ad bl ffc0a254 <rtems_aio_remove_req>
ffc099ac: 7c 7e 1b 78 mr r30,r3
pthread_mutex_unlock (&aio_request_queue.mutex);
ffc099b0: 7f e3 fb 78 mr r3,r31
ffc099b4: 48 00 16 3d bl ffc0aff0 <pthread_mutex_unlock>
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
return AIO_ALLDONE;
}
ffc099b8: 80 01 00 1c lwz r0,28(r1)
ffc099bc: 7f c3 f3 78 mr r3,r30
ffc099c0: 83 81 00 08 lwz r28,8(r1)
ffc099c4: 7c 08 03 a6 mtlr r0
ffc099c8: 83 a1 00 0c lwz r29,12(r1)
ffc099cc: 83 c1 00 10 lwz r30,16(r1)
ffc099d0: 83 e1 00 14 lwz r31,20(r1)
ffc099d4: 38 21 00 18 addi r1,r1,24
ffc099d8: 4e 80 00 20 blr
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
} else {
pthread_mutex_unlock (&aio_request_queue.mutex);
ffc099dc: 7f e3 fb 78 mr r3,r31
ffc099e0: 48 00 16 11 bl ffc0aff0 <pthread_mutex_unlock>
return AIO_ALLDONE;
ffc099e4: 3b c0 00 02 li r30,2
ffc099e8: 4b ff ff 6c b ffc09954 <aio_cancel+0xa4>
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
if (r_chain == NULL) {
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
if (r_chain == NULL) {
pthread_mutex_unlock (&aio_request_queue.mutex);
ffc099ec: 7f e3 fb 78 mr r3,r31
ffc099f0: 48 00 16 01 bl ffc0aff0 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EINVAL);
ffc099f4: 3b c0 ff ff li r30,-1
ffc099f8: 48 00 d2 d1 bl ffc16cc8 <__errno>
ffc099fc: 38 00 00 16 li r0,22
ffc09a00: 90 03 00 00 stw r0,0(r3)
ffc09a04: 4b ff ff 50 b ffc09954 <aio_cancel+0xa4>
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
AIO_printf ("Cancel all requests\n");
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
ffc09a08: 38 7f 00 48 addi r3,r31,72
ffc09a0c: 7f a4 eb 78 mr r4,r29
ffc09a10: 38 a0 00 00 li r5,0
ffc09a14: 48 00 02 c5 bl ffc09cd8 <rtems_aio_search_fd>
if (r_chain == NULL) {
ffc09a18: 7c 7e 1b 79 mr. r30,r3
ffc09a1c: 41 82 00 38 beq- ffc09a54 <aio_cancel+0x1a4>
return AIO_ALLDONE;
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
ffc09a20: 3b be 00 1c addi r29,r30,28
ffc09a24: 7f a3 eb 78 mr r3,r29
ffc09a28: 48 00 14 fd bl ffc0af24 <pthread_mutex_lock>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
ffc09a2c: 7f c3 f3 78 mr r3,r30
ffc09a30: 48 00 37 5d bl ffc0d18c <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
ffc09a34: 7f c3 f3 78 mr r3,r30
ffc09a38: 48 00 07 95 bl ffc0a1cc <rtems_aio_remove_fd>
pthread_mutex_unlock (&r_chain->mutex);
ffc09a3c: 7f a3 eb 78 mr r3,r29
ffc09a40: 48 00 15 b1 bl ffc0aff0 <pthread_mutex_unlock>
pthread_mutex_unlock (&aio_request_queue.mutex);
ffc09a44: 7f e3 fb 78 mr r3,r31
ffc09a48: 48 00 15 a9 bl ffc0aff0 <pthread_mutex_unlock>
return AIO_CANCELED;
ffc09a4c: 3b c0 00 00 li r30,0
ffc09a50: 4b ff ff 04 b ffc09954 <aio_cancel+0xa4>
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
if (r_chain == NULL) {
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
ffc09a54: 81 3f 00 54 lwz r9,84(r31)
ffc09a58: 38 1f 00 58 addi r0,r31,88
ffc09a5c: 7f 89 00 00 cmpw cr7,r9,r0
ffc09a60: 41 be ff 7c beq- cr7,ffc099dc <aio_cancel+0x12c> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
ffc09a64: 38 7f 00 54 addi r3,r31,84
ffc09a68: 7f a4 eb 78 mr r4,r29
ffc09a6c: 38 a0 00 00 li r5,0
ffc09a70: 48 00 02 69 bl ffc09cd8 <rtems_aio_search_fd>
if (r_chain == NULL) {
ffc09a74: 7c 7e 1b 79 mr. r30,r3
ffc09a78: 41 a2 ff 64 beq- ffc099dc <aio_cancel+0x12c>
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
pthread_mutex_destroy (&r_chain->mutex);
ffc09a7c: 3b be 00 1c addi r29,r30,28
ffc09a80: 48 00 37 0d bl ffc0d18c <_Chain_Extract>
}
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
ffc09a84: 7f c3 f3 78 mr r3,r30
ffc09a88: 48 00 07 45 bl ffc0a1cc <rtems_aio_remove_fd>
pthread_mutex_destroy (&r_chain->mutex);
ffc09a8c: 7f a3 eb 78 mr r3,r29
ffc09a90: 48 00 11 49 bl ffc0abd8 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->mutex);
ffc09a94: 7f a3 eb 78 mr r3,r29
ffc09a98: 48 00 0c 89 bl ffc0a720 <pthread_cond_destroy>
free (r_chain);
ffc09a9c: 7f c3 f3 78 mr r3,r30
ffc09aa0: 4b ff bf 71 bl ffc05a10 <free>
pthread_mutex_unlock (&aio_request_queue.mutex);
ffc09aa4: 7f e3 fb 78 mr r3,r31
ffc09aa8: 48 00 15 49 bl ffc0aff0 <pthread_mutex_unlock>
return AIO_CANCELED;
ffc09aac: 3b c0 00 00 li r30,0
ffc09ab0: 4b ff fe a4 b ffc09954 <aio_cancel+0xa4>
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
if (fcntl (fildes, F_GETFD) < 0) {
pthread_mutex_unlock(&aio_request_queue.mutex);
ffc09ab4: 7f e3 fb 78 mr r3,r31
ffc09ab8: 48 00 15 39 bl ffc0aff0 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EBADF);
ffc09abc: 3b c0 ff ff li r30,-1
ffc09ac0: 48 00 d2 09 bl ffc16cc8 <__errno>
ffc09ac4: 38 00 00 09 li r0,9
ffc09ac8: 90 03 00 00 stw r0,0(r3)
ffc09acc: 4b ff fe 88 b ffc09954 <aio_cancel+0xa4>
ffc09ad8 <aio_fsync>:
)
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
ffc09ad8: 2f 83 20 00 cmpwi cr7,r3,8192
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
ffc09adc: 94 21 ff f0 stwu r1,-16(r1)
ffc09ae0: 7c 08 02 a6 mflr r0
ffc09ae4: 93 c1 00 08 stw r30,8(r1)
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
ffc09ae8: 3b c0 00 16 li r30,22
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
ffc09aec: 93 e1 00 0c stw r31,12(r1)
ffc09af0: 7c 9f 23 78 mr r31,r4
ffc09af4: 90 01 00 14 stw r0,20(r1)
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
ffc09af8: 40 9e 00 64 bne- cr7,ffc09b5c <aio_fsync+0x84>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
ffc09afc: 80 64 00 00 lwz r3,0(r4)
ffc09b00: 38 80 00 03 li r4,3
ffc09b04: 4c c6 31 82 crclr 4*cr1+eq
ffc09b08: 48 00 8d 5d bl ffc12864 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
ffc09b0c: 54 63 07 be clrlwi r3,r3,30
ffc09b10: 38 63 ff ff addi r3,r3,-1
ffc09b14: 2b 83 00 01 cmplwi cr7,r3,1
ffc09b18: 41 9d 00 40 bgt- cr7,ffc09b58 <aio_fsync+0x80>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
ffc09b1c: 38 60 00 18 li r3,24
ffc09b20: 4b ff c6 95 bl ffc061b4 <malloc>
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
ffc09b24: 3b c0 00 0b li r30,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)
ffc09b28: 7c 69 1b 79 mr. r9,r3
ffc09b2c: 41 82 00 30 beq- ffc09b5c <aio_fsync+0x84> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
ffc09b30: 38 00 00 03 li r0,3
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
ffc09b34: 93 e9 00 14 stw r31,20(r9)
req->aiocbp->aio_lio_opcode = LIO_SYNC;
ffc09b38: 90 1f 00 30 stw r0,48(r31)
return rtems_aio_enqueue (req);
ffc09b3c: 48 00 07 ad bl ffc0a2e8 <rtems_aio_enqueue>
}
ffc09b40: 80 01 00 14 lwz r0,20(r1)
ffc09b44: 83 c1 00 08 lwz r30,8(r1)
ffc09b48: 7c 08 03 a6 mtlr r0
ffc09b4c: 83 e1 00 0c lwz r31,12(r1)
ffc09b50: 38 21 00 10 addi r1,r1,16
ffc09b54: 4e 80 00 20 blr
if (op != O_SYNC)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
ffc09b58: 3b c0 00 09 li r30,9
ffc09b5c: 38 00 ff ff li r0,-1
ffc09b60: 93 df 00 34 stw r30,52(r31)
ffc09b64: 90 1f 00 38 stw r0,56(r31)
ffc09b68: 48 00 d1 61 bl ffc16cc8 <__errno>
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
}
ffc09b6c: 80 01 00 14 lwz r0,20(r1)
if (op != O_SYNC)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
ffc09b70: 93 c3 00 00 stw r30,0(r3)
ffc09b74: 38 60 ff ff li r3,-1
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
}
ffc09b78: 7c 08 03 a6 mtlr r0
ffc09b7c: 83 c1 00 08 lwz r30,8(r1)
ffc09b80: 83 e1 00 0c lwz r31,12(r1)
ffc09b84: 38 21 00 10 addi r1,r1,16
ffc09b88: 4e 80 00 20 blr
ffc0a518 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
ffc0a518: 94 21 ff f0 stwu r1,-16(r1)
ffc0a51c: 7c 08 02 a6 mflr r0
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
ffc0a520: 38 80 00 03 li r4,3
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
ffc0a524: 90 01 00 14 stw r0,20(r1)
ffc0a528: 93 e1 00 0c stw r31,12(r1)
ffc0a52c: 7c 7f 1b 78 mr r31,r3
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
ffc0a530: 80 63 00 00 lwz r3,0(r3)
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
ffc0a534: 93 c1 00 08 stw r30,8(r1)
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
ffc0a538: 4c c6 31 82 crclr 4*cr1+eq
ffc0a53c: 48 00 83 29 bl ffc12864 <fcntl>
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
ffc0a540: 70 63 00 03 andi. r3,r3,3
ffc0a544: 41 82 00 10 beq- ffc0a554 <aio_read+0x3c> <== NEVER TAKEN
ffc0a548: 2f 83 00 02 cmpwi cr7,r3,2
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
ffc0a54c: 3b c0 00 09 li r30,9
{
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
ffc0a550: 40 9e 00 5c bne- cr7,ffc0a5ac <aio_read+0x94>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
ffc0a554: 80 1f 00 18 lwz r0,24(r31)
ffc0a558: 2f 80 00 00 cmpwi cr7,r0,0
ffc0a55c: 40 9e 00 4c bne- cr7,ffc0a5a8 <aio_read+0x90>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
ffc0a560: 80 1f 00 08 lwz r0,8(r31)
ffc0a564: 2f 80 00 00 cmpwi cr7,r0,0
ffc0a568: 41 9c 00 40 blt- cr7,ffc0a5a8 <aio_read+0x90>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
ffc0a56c: 38 60 00 18 li r3,24
ffc0a570: 4b ff bc 45 bl ffc061b4 <malloc>
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
ffc0a574: 3b c0 00 0b li r30,11
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
ffc0a578: 7c 69 1b 79 mr. r9,r3
ffc0a57c: 41 82 00 30 beq- ffc0a5ac <aio_read+0x94> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
ffc0a580: 38 00 00 01 li r0,1
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
ffc0a584: 93 e9 00 14 stw r31,20(r9)
req->aiocbp->aio_lio_opcode = LIO_READ;
ffc0a588: 90 1f 00 30 stw r0,48(r31)
return rtems_aio_enqueue (req);
ffc0a58c: 4b ff fd 5d bl ffc0a2e8 <rtems_aio_enqueue>
}
ffc0a590: 80 01 00 14 lwz r0,20(r1)
ffc0a594: 83 c1 00 08 lwz r30,8(r1)
ffc0a598: 7c 08 03 a6 mtlr r0
ffc0a59c: 83 e1 00 0c lwz r31,12(r1)
ffc0a5a0: 38 21 00 10 addi r1,r1,16
ffc0a5a4: 4e 80 00 20 blr
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
ffc0a5a8: 3b c0 00 16 li r30,22
ffc0a5ac: 38 00 ff ff li r0,-1
ffc0a5b0: 93 df 00 34 stw r30,52(r31)
ffc0a5b4: 90 1f 00 38 stw r0,56(r31)
ffc0a5b8: 48 00 c7 11 bl ffc16cc8 <__errno>
ffc0a5bc: 93 c3 00 00 stw r30,0(r3)
ffc0a5c0: 38 60 ff ff li r3,-1
ffc0a5c4: 4b ff ff cc b ffc0a590 <aio_read+0x78>
ffc0a5d0 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
ffc0a5d0: 94 21 ff f0 stwu r1,-16(r1)
ffc0a5d4: 7c 08 02 a6 mflr r0
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
ffc0a5d8: 38 80 00 03 li r4,3
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
ffc0a5dc: 90 01 00 14 stw r0,20(r1)
ffc0a5e0: 93 e1 00 0c stw r31,12(r1)
ffc0a5e4: 7c 7f 1b 78 mr r31,r3
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
ffc0a5e8: 80 63 00 00 lwz r3,0(r3)
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
ffc0a5ec: 93 c1 00 08 stw r30,8(r1)
rtems_aio_request *req;
int mode;
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);
ffc0a5f0: 3b c0 00 09 li r30,9
aio_write (struct aiocb *aiocbp)
{
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
ffc0a5f4: 4c c6 31 82 crclr 4*cr1+eq
ffc0a5f8: 48 00 82 6d bl ffc12864 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
ffc0a5fc: 54 63 07 be clrlwi r3,r3,30
ffc0a600: 38 63 ff ff addi r3,r3,-1
ffc0a604: 2b 83 00 01 cmplwi cr7,r3,1
ffc0a608: 41 9d 00 5c bgt- cr7,ffc0a664 <aio_write+0x94>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
ffc0a60c: 80 1f 00 18 lwz r0,24(r31)
ffc0a610: 2f 80 00 00 cmpwi cr7,r0,0
ffc0a614: 40 9e 00 4c bne- cr7,ffc0a660 <aio_write+0x90>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
ffc0a618: 80 1f 00 08 lwz r0,8(r31)
ffc0a61c: 2f 80 00 00 cmpwi cr7,r0,0
ffc0a620: 41 9c 00 40 blt- cr7,ffc0a660 <aio_write+0x90>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
ffc0a624: 38 60 00 18 li r3,24
ffc0a628: 4b ff bb 8d bl ffc061b4 <malloc>
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
ffc0a62c: 3b c0 00 0b li r30,11
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
ffc0a630: 7c 69 1b 79 mr. r9,r3
ffc0a634: 41 82 00 30 beq- ffc0a664 <aio_write+0x94> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
ffc0a638: 38 00 00 02 li r0,2
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
ffc0a63c: 93 e9 00 14 stw r31,20(r9)
req->aiocbp->aio_lio_opcode = LIO_WRITE;
ffc0a640: 90 1f 00 30 stw r0,48(r31)
return rtems_aio_enqueue (req);
ffc0a644: 4b ff fc a5 bl ffc0a2e8 <rtems_aio_enqueue>
}
ffc0a648: 80 01 00 14 lwz r0,20(r1)
ffc0a64c: 83 c1 00 08 lwz r30,8(r1)
ffc0a650: 7c 08 03 a6 mtlr r0
ffc0a654: 83 e1 00 0c lwz r31,12(r1)
ffc0a658: 38 21 00 10 addi r1,r1,16
ffc0a65c: 4e 80 00 20 blr
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);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
ffc0a660: 3b c0 00 16 li r30,22
ffc0a664: 38 00 ff ff li r0,-1
ffc0a668: 93 df 00 34 stw r30,52(r31)
ffc0a66c: 90 1f 00 38 stw r0,56(r31)
ffc0a670: 48 00 c6 59 bl ffc16cc8 <__errno>
ffc0a674: 93 c3 00 00 stw r30,0(r3)
ffc0a678: 38 60 ff ff li r3,-1
ffc0a67c: 4b ff ff cc b ffc0a648 <aio_write+0x78>
ffc06fa0 <chroot>:
#include <rtems/seterr.h>
int chroot(
const char *pathname
)
{
ffc06fa0: 94 21 ff c8 stwu r1,-56(r1)
ffc06fa4: 7c 08 02 a6 mflr r0
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) {
ffc06fa8: 3d 20 00 00 lis r9,0
#include <rtems/seterr.h>
int chroot(
const char *pathname
)
{
ffc06fac: 93 e1 00 34 stw r31,52(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) {
ffc06fb0: 3f e0 00 00 lis r31,0
#include <rtems/seterr.h>
int chroot(
const char *pathname
)
{
ffc06fb4: 93 c1 00 30 stw r30,48(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) {
ffc06fb8: 83 df 27 5c lwz r30,10076(r31)
#include <rtems/seterr.h>
int chroot(
const char *pathname
)
{
ffc06fbc: 90 01 00 3c stw r0,60(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) {
ffc06fc0: 38 09 2b 70 addi r0,r9,11120
ffc06fc4: 7f 9e 00 00 cmpw cr7,r30,r0
#include <rtems/seterr.h>
int chroot(
const char *pathname
)
{
ffc06fc8: 93 a1 00 2c stw r29,44(r1)
ffc06fcc: 7c 7d 1b 78 mr r29,r3
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) {
ffc06fd0: 41 9e 00 90 beq- cr7,ffc07060 <chroot+0xc0>
rtems_libio_set_private_env(); /* try to set a new private env*/
if (rtems_current_user_env == &rtems_global_user_env) /* not ok */
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = chdir(pathname);
ffc06fd4: 7f a3 eb 78 mr r3,r29
ffc06fd8: 4b ff fe e9 bl ffc06ec0 <chdir>
if (result) {
ffc06fdc: 2f 83 00 00 cmpwi cr7,r3,0
ffc06fe0: 40 9e 00 a4 bne- cr7,ffc07084 <chroot+0xe4>
rtems_set_errno_and_return_minus_one( errno );
}
/* clone the new root location */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
ffc06fe4: 3c 60 ff c2 lis r3,-62
ffc06fe8: 38 63 66 ac addi r3,r3,26284
ffc06fec: 38 80 00 01 li r4,1
ffc06ff0: 38 a0 00 00 li r5,0
ffc06ff4: 38 c1 00 08 addi r6,r1,8
ffc06ff8: 38 e0 00 00 li r7,0
ffc06ffc: 48 00 01 f1 bl ffc071ec <rtems_filesystem_evaluate_path>
ffc07000: 2f 83 00 00 cmpwi cr7,r3,0
ffc07004: 40 9e 00 80 bne- cr7,ffc07084 <chroot+0xe4> <== 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);
ffc07008: 80 7f 27 5c lwz r3,10076(r31)
ffc0700c: 38 63 00 18 addi r3,r3,24
ffc07010: 48 00 04 bd bl ffc074cc <rtems_filesystem_freenode>
rtems_filesystem_root = loc;
ffc07014: 81 3f 27 5c lwz r9,10076(r31)
ffc07018: 80 01 00 08 lwz r0,8(r1)
return 0;
ffc0701c: 38 60 00 00 li r3,0
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
/* 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);
rtems_filesystem_root = loc;
ffc07020: 90 09 00 18 stw r0,24(r9)
ffc07024: 80 01 00 0c lwz r0,12(r1)
ffc07028: 90 09 00 1c stw r0,28(r9)
ffc0702c: 80 01 00 10 lwz r0,16(r1)
ffc07030: 90 09 00 20 stw r0,32(r9)
ffc07034: 80 01 00 14 lwz r0,20(r1)
ffc07038: 90 09 00 24 stw r0,36(r9)
ffc0703c: 80 01 00 18 lwz r0,24(r1)
ffc07040: 90 09 00 28 stw r0,40(r9)
return 0;
}
ffc07044: 80 01 00 3c lwz r0,60(r1)
ffc07048: 83 a1 00 2c lwz r29,44(r1)
ffc0704c: 7c 08 03 a6 mtlr r0
ffc07050: 83 c1 00 30 lwz r30,48(r1)
ffc07054: 83 e1 00 34 lwz r31,52(r1)
ffc07058: 38 21 00 38 addi r1,r1,56
ffc0705c: 4e 80 00 20 blr
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) {
rtems_libio_set_private_env(); /* try to set a new private env*/
ffc07060: 48 00 1b b5 bl ffc08c14 <rtems_libio_set_private_env>
if (rtems_current_user_env == &rtems_global_user_env) /* not ok */
ffc07064: 80 1f 27 5c lwz r0,10076(r31)
ffc07068: 7f 80 f0 00 cmpw cr7,r0,r30
ffc0706c: 40 9e ff 68 bne+ cr7,ffc06fd4 <chroot+0x34>
rtems_set_errno_and_return_minus_one( ENOTSUP );
ffc07070: 48 00 f9 bd bl ffc16a2c <__errno>
ffc07074: 38 00 00 86 li r0,134
ffc07078: 90 03 00 00 stw r0,0(r3)
ffc0707c: 38 60 ff ff li r3,-1
ffc07080: 4b ff ff c4 b ffc07044 <chroot+0xa4>
}
/* clone the new root location */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
/* our cwd has changed, though - but there is no easy way of return :-( */
rtems_set_errno_and_return_minus_one( errno );
ffc07084: 48 00 f9 a9 bl ffc16a2c <__errno>
ffc07088: 7c 7f 1b 78 mr r31,r3
ffc0708c: 48 00 f9 a1 bl ffc16a2c <__errno>
ffc07090: 80 03 00 00 lwz r0,0(r3)
ffc07094: 38 60 ff ff li r3,-1
ffc07098: 90 1f 00 00 stw r0,0(r31)
ffc0709c: 4b ff ff a8 b ffc07044 <chroot+0xa4>
ffc08be8 <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
if ( !tp )
ffc08be8: 2c 04 00 00 cmpwi r4,0
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
ffc08bec: 94 21 ff f8 stwu r1,-8(r1)
ffc08bf0: 7c 08 02 a6 mflr r0
ffc08bf4: 90 01 00 0c stw r0,12(r1)
if ( !tp )
ffc08bf8: 41 82 00 24 beq- ffc08c1c <clock_gettime+0x34>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
ffc08bfc: 2f 83 00 01 cmpwi cr7,r3,1
ffc08c00: 41 9e 00 78 beq- cr7,ffc08c78 <clock_gettime+0x90>
_TOD_Get(tp);
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
ffc08c04: 2f 83 00 04 cmpwi cr7,r3,4
ffc08c08: 41 9e 00 54 beq- cr7,ffc08c5c <clock_gettime+0x74> <== NEVER TAKEN
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) {
ffc08c0c: 2f 83 00 02 cmpwi cr7,r3,2
ffc08c10: 41 9e 00 4c beq- cr7,ffc08c5c <clock_gettime+0x74>
return 0;
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
ffc08c14: 2f 83 00 03 cmpwi cr7,r3,3
ffc08c18: 41 9e 00 24 beq- cr7,ffc08c3c <clock_gettime+0x54>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
ffc08c1c: 48 00 c0 95 bl ffc14cb0 <__errno>
ffc08c20: 38 00 00 16 li r0,22
ffc08c24: 90 03 00 00 stw r0,0(r3)
ffc08c28: 38 60 ff ff li r3,-1
return 0;
}
ffc08c2c: 80 01 00 0c lwz r0,12(r1)
ffc08c30: 38 21 00 08 addi r1,r1,8
ffc08c34: 7c 08 03 a6 mtlr r0
ffc08c38: 4e 80 00 20 blr
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
rtems_set_errno_and_return_minus_one( ENOSYS );
ffc08c3c: 48 00 c0 75 bl ffc14cb0 <__errno>
ffc08c40: 38 00 00 58 li r0,88
ffc08c44: 90 03 00 00 stw r0,0(r3)
ffc08c48: 38 60 ff ff li r3,-1
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
ffc08c4c: 80 01 00 0c lwz r0,12(r1)
ffc08c50: 38 21 00 08 addi r1,r1,8
ffc08c54: 7c 08 03 a6 mtlr r0
ffc08c58: 4e 80 00 20 blr
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) {
_TOD_Get_uptime_as_timespec( tp );
ffc08c5c: 7c 83 23 78 mr r3,r4
ffc08c60: 48 00 29 45 bl ffc0b5a4 <_TOD_Get_uptime_as_timespec>
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
ffc08c64: 80 01 00 0c lwz r0,12(r1)
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) {
_TOD_Get_uptime_as_timespec( tp );
return 0;
ffc08c68: 38 60 00 00 li r3,0
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
ffc08c6c: 7c 08 03 a6 mtlr r0
ffc08c70: 38 21 00 08 addi r1,r1,8
ffc08c74: 4e 80 00 20 blr
{
if ( !tp )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
_TOD_Get(tp);
ffc08c78: 7c 83 23 78 mr r3,r4
ffc08c7c: 48 00 28 91 bl ffc0b50c <_TOD_Get>
return 0;
ffc08c80: 38 60 00 00 li r3,0
ffc08c84: 4b ff ff a8 b ffc08c2c <clock_gettime+0x44>
ffc08c88 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
if ( !tp )
ffc08c88: 2c 04 00 00 cmpwi r4,0
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
ffc08c8c: 94 21 ff f8 stwu r1,-8(r1)
ffc08c90: 7c 08 02 a6 mflr r0
ffc08c94: 90 01 00 0c stw r0,12(r1)
if ( !tp )
ffc08c98: 41 82 00 1c beq- ffc08cb4 <clock_settime+0x2c> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
ffc08c9c: 2f 83 00 01 cmpwi cr7,r3,1
ffc08ca0: 41 9e 00 34 beq- cr7,ffc08cd4 <clock_settime+0x4c>
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME_ID )
ffc08ca4: 2f 83 00 02 cmpwi cr7,r3,2
ffc08ca8: 41 9e 00 74 beq- cr7,ffc08d1c <clock_settime+0x94>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
ffc08cac: 2f 83 00 03 cmpwi cr7,r3,3
ffc08cb0: 41 9e 00 6c beq- cr7,ffc08d1c <clock_settime+0x94>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
ffc08cb4: 48 00 bf fd bl ffc14cb0 <__errno>
ffc08cb8: 38 00 00 16 li r0,22
ffc08cbc: 90 03 00 00 stw r0,0(r3)
ffc08cc0: 38 60 ff ff li r3,-1
return 0;
}
ffc08cc4: 80 01 00 0c lwz r0,12(r1)
ffc08cc8: 38 21 00 08 addi r1,r1,8
ffc08ccc: 7c 08 03 a6 mtlr r0
ffc08cd0: 4e 80 00 20 blr
{
if ( !tp )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
ffc08cd4: 81 24 00 00 lwz r9,0(r4)
ffc08cd8: 3c 00 21 da lis r0,8666
ffc08cdc: 60 00 e4 ff ori r0,r0,58623
ffc08ce0: 7f 89 00 40 cmplw cr7,r9,r0
ffc08ce4: 40 bd ff d0 ble- cr7,ffc08cb4 <clock_settime+0x2c>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc08ce8: 3d 20 00 00 lis r9,0
ffc08cec: 81 69 28 78 lwz r11,10360(r9)
ffc08cf0: 38 0b 00 01 addi r0,r11,1
ffc08cf4: 90 09 28 78 stw r0,10360(r9)
return _Thread_Dispatch_disable_level;
ffc08cf8: 80 09 28 78 lwz r0,10360(r9)
rtems_set_errno_and_return_minus_one( EINVAL );
_Thread_Disable_dispatch();
_TOD_Set( tp );
ffc08cfc: 7c 83 23 78 mr r3,r4
ffc08d00: 48 00 29 1d bl ffc0b61c <_TOD_Set>
_Thread_Enable_dispatch();
ffc08d04: 48 00 46 49 bl ffc0d34c <_Thread_Enable_dispatch>
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
ffc08d08: 80 01 00 0c lwz r0,12(r1)
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
ffc08d0c: 38 60 00 00 li r3,0
}
ffc08d10: 7c 08 03 a6 mtlr r0
ffc08d14: 38 21 00 08 addi r1,r1,8
ffc08d18: 4e 80 00 20 blr
else if ( clock_id == CLOCK_PROCESS_CPUTIME_ID )
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
rtems_set_errno_and_return_minus_one( ENOSYS );
ffc08d1c: 48 00 bf 95 bl ffc14cb0 <__errno>
ffc08d20: 38 00 00 58 li r0,88
ffc08d24: 90 03 00 00 stw r0,0(r3)
ffc08d28: 38 60 ff ff li r3,-1
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
ffc08d2c: 80 01 00 0c lwz r0,12(r1)
ffc08d30: 38 21 00 08 addi r1,r1,8
ffc08d34: 7c 08 03 a6 mtlr r0
ffc08d38: 4e 80 00 20 blr
ffc04508 <create_disk>:
return disktab [major].minor + minor;
}
static rtems_status_code
create_disk(dev_t dev, const char *name, rtems_disk_device **dd_ptr)
{
ffc04508: 94 21 ff d0 stwu r1,-48(r1)
ffc0450c: 7c 08 02 a6 mflr r0
ffc04510: 93 a1 00 24 stw r29,36(r1)
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major >= disktab_size) {
ffc04514: 3f a0 00 00 lis r29,0
return disktab [major].minor + minor;
}
static rtems_status_code
create_disk(dev_t dev, const char *name, rtems_disk_device **dd_ptr)
{
ffc04518: 93 81 00 20 stw r28,32(r1)
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major >= disktab_size) {
ffc0451c: 83 9d 28 e8 lwz r28,10472(r29)
return disktab [major].minor + minor;
}
static rtems_status_code
create_disk(dev_t dev, const char *name, rtems_disk_device **dd_ptr)
{
ffc04520: 92 e1 00 0c stw r23,12(r1)
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major >= disktab_size) {
ffc04524: 3a fd 28 e8 addi r23,r29,10472
ffc04528: 7f 83 e0 40 cmplw cr7,r3,r28
return disktab [major].minor + minor;
}
static rtems_status_code
create_disk(dev_t dev, const char *name, rtems_disk_device **dd_ptr)
{
ffc0452c: 93 41 00 18 stw r26,24(r1)
ffc04530: 7c da 33 78 mr r26,r6
ffc04534: 93 61 00 1c stw r27,28(r1)
ffc04538: 7c bb 2b 78 mr r27,r5
ffc0453c: 93 c1 00 28 stw r30,40(r1)
ffc04540: 7c 9e 23 78 mr r30,r4
ffc04544: 93 e1 00 2c stw r31,44(r1)
ffc04548: 7c 7f 1b 78 mr r31,r3
ffc0454c: 90 01 00 34 stw r0,52(r1)
ffc04550: 92 c1 00 08 stw r22,8(r1)
ffc04554: 93 01 00 10 stw r24,16(r1)
ffc04558: 93 21 00 14 stw r25,20(r1)
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major >= disktab_size) {
ffc0455c: 40 9c 00 d4 bge- cr7,ffc04630 <create_disk+0x128>
ffc04560: 83 37 00 04 lwz r25,4(r23)
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
disktab = table;
disktab_size = new_size;
}
if (disktab [major].minor == NULL || minor >= disktab[major].size) {
ffc04564: 57 e0 18 38 rlwinm r0,r31,3,0,28
ffc04568: 7f 99 00 2e lwzx r28,r25,r0
ffc0456c: 7f 39 02 14 add r25,r25,r0
ffc04570: 83 19 00 04 lwz r24,4(r25)
ffc04574: 2f 9c 00 00 cmpwi cr7,r28,0
ffc04578: 41 9e 00 68 beq- cr7,ffc045e0 <create_disk+0xd8>
ffc0457c: 7f 9e c0 40 cmplw cr7,r30,r24
ffc04580: 40 9c 00 60 bge- cr7,ffc045e0 <create_disk+0xd8> <== NEVER TAKEN
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
disktab [major].minor = table;
disktab [major].size = new_size;
}
return disktab [major].minor + minor;
ffc04584: 57 c0 10 3a rlwinm r0,r30,2,0,29
{
rtems_disk_device **dd_entry = create_disk_table_entry(dev);
rtems_disk_device *dd = NULL;
char *alloc_name = NULL;
if (dd_entry == NULL) {
ffc04588: 7f bc 02 15 add. r29,r28,r0
return RTEMS_NO_MEMORY;
ffc0458c: 3a c0 00 1a li r22,26
{
rtems_disk_device **dd_entry = create_disk_table_entry(dev);
rtems_disk_device *dd = NULL;
char *alloc_name = NULL;
if (dd_entry == NULL) {
ffc04590: 41 82 00 14 beq- ffc045a4 <create_disk+0x9c> <== NEVER TAKEN
return RTEMS_NO_MEMORY;
}
if (*dd_entry != NULL) {
ffc04594: 7c 1c 00 2e lwzx r0,r28,r0
return RTEMS_RESOURCE_IN_USE;
ffc04598: 3a c0 00 0c li r22,12
if (dd_entry == NULL) {
return RTEMS_NO_MEMORY;
}
if (*dd_entry != NULL) {
ffc0459c: 2f 80 00 00 cmpwi cr7,r0,0
ffc045a0: 41 9e 00 f4 beq- cr7,ffc04694 <create_disk+0x18c>
*dd_entry = dd;
*dd_ptr = dd;
return RTEMS_SUCCESSFUL;
}
ffc045a4: 80 01 00 34 lwz r0,52(r1)
ffc045a8: 7e c3 b3 78 mr r3,r22
ffc045ac: 82 e1 00 0c lwz r23,12(r1)
ffc045b0: 7c 08 03 a6 mtlr r0
ffc045b4: 82 c1 00 08 lwz r22,8(r1)
ffc045b8: 83 01 00 10 lwz r24,16(r1)
ffc045bc: 83 21 00 14 lwz r25,20(r1)
ffc045c0: 83 41 00 18 lwz r26,24(r1)
ffc045c4: 83 61 00 1c lwz r27,28(r1)
ffc045c8: 83 81 00 20 lwz r28,32(r1)
ffc045cc: 83 a1 00 24 lwz r29,36(r1)
ffc045d0: 83 c1 00 28 lwz r30,40(r1)
ffc045d4: 83 e1 00 2c lwz r31,44(r1)
ffc045d8: 38 21 00 30 addi r1,r1,48
ffc045dc: 4e 80 00 20 blr
if (disktab [major].minor == NULL || minor >= disktab[major].size) {
rtems_disk_device **table = disktab [major].minor;
rtems_device_minor_number old_size = disktab [major].size;
rtems_device_minor_number new_size = 0;
if (old_size == 0) {
ffc045e0: 2f 98 00 00 cmpwi cr7,r24,0
new_size = DISKTAB_INITIAL_SIZE;
ffc045e4: 3b a0 00 08 li r29,8
if (disktab [major].minor == NULL || minor >= disktab[major].size) {
rtems_disk_device **table = disktab [major].minor;
rtems_device_minor_number old_size = disktab [major].size;
rtems_device_minor_number new_size = 0;
if (old_size == 0) {
ffc045e8: 40 9e 00 9c bne- cr7,ffc04684 <create_disk+0x17c> <== NEVER TAKEN
new_size = DISKTAB_INITIAL_SIZE;
} else {
new_size = 2 * old_size;
}
if (minor >= new_size) {
ffc045ec: 7f 9e e8 40 cmplw cr7,r30,r29
ffc045f0: 40 9c 00 8c bge- cr7,ffc0467c <create_disk+0x174>
new_size = minor + 1;
}
table = realloc(table, new_size * sizeof(*table));
ffc045f4: 7f 83 e3 78 mr r3,r28
ffc045f8: 57 a4 10 3a rlwinm r4,r29,2,0,29
ffc045fc: 48 00 28 fd bl ffc06ef8 <realloc>
rtems_disk_device **dd_entry = create_disk_table_entry(dev);
rtems_disk_device *dd = NULL;
char *alloc_name = NULL;
if (dd_entry == NULL) {
return RTEMS_NO_MEMORY;
ffc04600: 3a c0 00 1a li r22,26
if (minor >= new_size) {
new_size = minor + 1;
}
table = realloc(table, new_size * sizeof(*table));
if (table == NULL) {
ffc04604: 7c 7c 1b 79 mr. r28,r3
ffc04608: 41 a2 ff 9c beq- ffc045a4 <create_disk+0x9c>
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
ffc0460c: 7c b8 e8 50 subf r5,r24,r29
ffc04610: 57 03 10 3a rlwinm r3,r24,2,0,29
ffc04614: 7c 7c 1a 14 add r3,r28,r3
ffc04618: 38 80 00 00 li r4,0
ffc0461c: 54 a5 10 3a rlwinm r5,r5,2,0,29
ffc04620: 48 01 4c 11 bl ffc19230 <memset>
disktab [major].minor = table;
ffc04624: 93 99 00 00 stw r28,0(r25)
disktab [major].size = new_size;
ffc04628: 93 b9 00 04 stw r29,4(r25)
ffc0462c: 4b ff ff 58 b ffc04584 <create_disk+0x7c>
rtems_filesystem_split_dev_t(dev, major, minor);
if (major >= disktab_size) {
rtems_disk_device_table *table = disktab;
rtems_device_major_number old_size = disktab_size;
rtems_device_major_number new_size = 2 * old_size;
ffc04630: 57 98 08 3c rlwinm r24,r28,1,0,30
if (major >= new_size) {
ffc04634: 7f 83 c0 40 cmplw cr7,r3,r24
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major >= disktab_size) {
rtems_disk_device_table *table = disktab;
ffc04638: 80 77 00 04 lwz r3,4(r23)
rtems_device_major_number old_size = disktab_size;
rtems_device_major_number new_size = 2 * old_size;
if (major >= new_size) {
ffc0463c: 41 9c 00 08 blt- cr7,ffc04644 <create_disk+0x13c> <== NEVER TAKEN
new_size = major + 1;
ffc04640: 3b 1f 00 01 addi r24,r31,1
}
table = realloc(table, new_size * sizeof(*table));
ffc04644: 57 04 18 38 rlwinm r4,r24,3,0,28
ffc04648: 48 00 28 b1 bl ffc06ef8 <realloc>
rtems_disk_device **dd_entry = create_disk_table_entry(dev);
rtems_disk_device *dd = NULL;
char *alloc_name = NULL;
if (dd_entry == NULL) {
return RTEMS_NO_MEMORY;
ffc0464c: 3a c0 00 1a li r22,26
if (major >= new_size) {
new_size = major + 1;
}
table = realloc(table, new_size * sizeof(*table));
if (table == NULL) {
ffc04650: 7c 79 1b 79 mr. r25,r3
ffc04654: 41 a2 ff 50 beq- ffc045a4 <create_disk+0x9c> <== ALWAYS TAKEN
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
ffc04658: 7c bc c0 50 subf r5,r28,r24 <== NOT EXECUTED
ffc0465c: 57 83 18 38 rlwinm r3,r28,3,0,28 <== NOT EXECUTED
ffc04660: 7c 79 1a 14 add r3,r25,r3 <== NOT EXECUTED
ffc04664: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc04668: 54 a5 18 38 rlwinm r5,r5,3,0,28 <== NOT EXECUTED
ffc0466c: 48 01 4b c5 bl ffc19230 <memset> <== NOT EXECUTED
disktab = table;
ffc04670: 93 37 00 04 stw r25,4(r23) <== NOT EXECUTED
disktab_size = new_size;
ffc04674: 93 1d 28 e8 stw r24,10472(r29) <== NOT EXECUTED
ffc04678: 4b ff fe ec b ffc04564 <create_disk+0x5c> <== NOT EXECUTED
new_size = DISKTAB_INITIAL_SIZE;
} else {
new_size = 2 * old_size;
}
if (minor >= new_size) {
new_size = minor + 1;
ffc0467c: 3b be 00 01 addi r29,r30,1
ffc04680: 4b ff ff 74 b ffc045f4 <create_disk+0xec>
rtems_device_minor_number new_size = 0;
if (old_size == 0) {
new_size = DISKTAB_INITIAL_SIZE;
} else {
new_size = 2 * old_size;
ffc04684: 57 1d 08 3c rlwinm r29,r24,1,0,30 <== NOT EXECUTED
}
if (minor >= new_size) {
ffc04688: 7f 9e e8 40 cmplw cr7,r30,r29 <== NOT EXECUTED
ffc0468c: 41 bc ff 68 blt- cr7,ffc045f4 <create_disk+0xec> <== NOT EXECUTED
ffc04690: 4b ff ff ec b ffc0467c <create_disk+0x174> <== NOT EXECUTED
if (*dd_entry != NULL) {
return RTEMS_RESOURCE_IN_USE;
}
dd = malloc(sizeof(*dd));
ffc04694: 38 60 00 38 li r3,56
ffc04698: 48 00 1a a1 bl ffc06138 <malloc>
if (dd == NULL) {
return RTEMS_NO_MEMORY;
ffc0469c: 3a c0 00 1a li r22,26
if (*dd_entry != NULL) {
return RTEMS_RESOURCE_IN_USE;
}
dd = malloc(sizeof(*dd));
if (dd == NULL) {
ffc046a0: 7c 7c 1b 79 mr. r28,r3
ffc046a4: 41 a2 ff 00 beq- ffc045a4 <create_disk+0x9c> <== NEVER TAKEN
return RTEMS_NO_MEMORY;
}
if (name != NULL) {
ffc046a8: 2f 9b 00 00 cmpwi cr7,r27,0
ffc046ac: 41 9e 00 5c beq- cr7,ffc04708 <create_disk+0x200>
alloc_name = strdup(name);
ffc046b0: 7f 63 db 78 mr r3,r27
ffc046b4: 48 01 4f 51 bl ffc19604 <strdup>
if (alloc_name == NULL) {
ffc046b8: 2f 83 00 00 cmpwi cr7,r3,0
if (dd == NULL) {
return RTEMS_NO_MEMORY;
}
if (name != NULL) {
alloc_name = strdup(name);
ffc046bc: 7c 7b 1b 78 mr r27,r3
ffc046c0: 7c 79 1b 78 mr r25,r3
if (alloc_name == NULL) {
ffc046c4: 41 9e 00 64 beq- cr7,ffc04728 <create_disk+0x220> <== NEVER TAKEN
return RTEMS_NO_MEMORY;
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
ffc046c8: 38 80 61 ff li r4,25087
ffc046cc: 7f e5 fb 78 mr r5,r31
ffc046d0: 7f c6 f3 78 mr r6,r30
ffc046d4: 48 00 1b c5 bl ffc06298 <mknod>
ffc046d8: 2f 83 00 00 cmpwi cr7,r3,0
ffc046dc: 41 9c 00 34 blt- cr7,ffc04710 <create_disk+0x208> <== NEVER TAKEN
}
}
dd->dev = dev;
dd->name = alloc_name;
dd->uses = 0;
ffc046e0: 38 00 00 00 li r0,0
free(dd);
return RTEMS_UNSATISFIED;
}
}
dd->dev = dev;
ffc046e4: 93 fc 00 00 stw r31,0(r28)
dd->deleted = false;
*dd_entry = dd;
*dd_ptr = dd;
return RTEMS_SUCCESSFUL;
ffc046e8: 3a c0 00 00 li r22,0
free(dd);
return RTEMS_UNSATISFIED;
}
}
dd->dev = dev;
ffc046ec: 93 dc 00 04 stw r30,4(r28)
dd->name = alloc_name;
ffc046f0: 93 3c 00 10 stw r25,16(r28)
dd->uses = 0;
ffc046f4: 90 1c 00 14 stw r0,20(r28)
dd->deleted = false;
ffc046f8: 98 1c 00 30 stb r0,48(r28)
*dd_entry = dd;
ffc046fc: 93 9d 00 00 stw r28,0(r29)
*dd_ptr = dd;
ffc04700: 93 9a 00 00 stw r28,0(r26)
return RTEMS_SUCCESSFUL;
ffc04704: 4b ff fe a0 b ffc045a4 <create_disk+0x9c>
static rtems_status_code
create_disk(dev_t dev, const char *name, rtems_disk_device **dd_ptr)
{
rtems_disk_device **dd_entry = create_disk_table_entry(dev);
rtems_disk_device *dd = NULL;
char *alloc_name = NULL;
ffc04708: 3b 20 00 00 li r25,0
ffc0470c: 4b ff ff d4 b ffc046e0 <create_disk+0x1d8>
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
free(alloc_name);
ffc04710: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc04714: 48 00 16 09 bl ffc05d1c <free> <== NOT EXECUTED
free(dd);
ffc04718: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc0471c: 48 00 16 01 bl ffc05d1c <free> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
ffc04720: 3a c0 00 0d li r22,13 <== NOT EXECUTED
ffc04724: 4b ff fe 80 b ffc045a4 <create_disk+0x9c> <== NOT EXECUTED
if (name != NULL) {
alloc_name = strdup(name);
if (alloc_name == NULL) {
free(dd);
ffc04728: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc0472c: 48 00 15 f1 bl ffc05d1c <free> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
ffc04730: 4b ff fe 74 b ffc045a4 <create_disk+0x9c> <== NOT EXECUTED
ffc0dc30 <devFS_evaluate_path>:
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
ffc0dc30: 94 21 ff d8 stwu r1,-40(r1)
ffc0dc34: 7c 08 02 a6 mflr r0
ffc0dc38: 90 01 00 2c stw r0,44(r1)
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
ffc0dc3c: 54 a0 00 39 rlwinm. r0,r5,0,0,28
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
ffc0dc40: 93 01 00 08 stw r24,8(r1)
ffc0dc44: 7c d8 33 78 mr r24,r6
ffc0dc48: 93 c1 00 20 stw r30,32(r1)
ffc0dc4c: 7c 7e 1b 78 mr r30,r3
ffc0dc50: 93 e1 00 24 stw r31,36(r1)
ffc0dc54: 7c 9f 23 78 mr r31,r4
ffc0dc58: 93 21 00 0c stw r25,12(r1)
ffc0dc5c: 93 41 00 10 stw r26,16(r1)
ffc0dc60: 93 61 00 14 stw r27,20(r1)
ffc0dc64: 93 81 00 18 stw r28,24(r1)
ffc0dc68: 93 a1 00 1c stw r29,28(r1)
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
ffc0dc6c: 40 82 01 0c bne- ffc0dd78 <devFS_evaluate_path+0x148> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
ffc0dc70: 83 66 00 00 lwz r27,0(r6)
if (!device_name_table)
ffc0dc74: 2f 9b 00 00 cmpwi cr7,r27,0
ffc0dc78: 41 9e 01 14 beq- cr7,ffc0dd8c <devFS_evaluate_path+0x15c>
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++) {
ffc0dc7c: 3d 20 00 00 lis r9,0
ffc0dc80: 83 49 27 78 lwz r26,10104(r9)
ffc0dc84: 38 00 00 00 li r0,0
* handlers.
*/
extern rtems_filesystem_file_handlers_r devFS_file_handlers;
int devFS_evaluate_path(
ffc0dc88: 3b a0 00 00 li r29,0
/* 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++) {
ffc0dc8c: 2f 9a 00 00 cmpwi cr7,r26,0
ffc0dc90: 41 9e 00 4c beq- cr7,ffc0dcdc <devFS_evaluate_path+0xac><== NEVER TAKEN
if (!device_name_table[i].device_name)
ffc0dc94: 1c 00 00 14 mulli r0,r0,20
ffc0dc98: 7f 9b 00 2e lwzx r28,r27,r0
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
ffc0dc9c: 7f c3 f3 78 mr r3,r30
ffc0dca0: 7f e5 fb 78 mr r5,r31
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++) {
if (!device_name_table[i].device_name)
ffc0dca4: 2f 9c 00 00 cmpwi cr7,r28,0
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
ffc0dca8: 7f 84 e3 78 mr r4,r28
/* 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++) {
ffc0dcac: 3b bd 00 01 addi r29,r29,1
if (!device_name_table[i].device_name)
ffc0dcb0: 7f 3b 02 14 add r25,r27,r0
ffc0dcb4: 41 9e 00 1c beq- cr7,ffc0dcd0 <devFS_evaluate_path+0xa0>
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
ffc0dcb8: 48 00 43 19 bl ffc11fd0 <strncmp>
ffc0dcbc: 2f 83 00 00 cmpwi cr7,r3,0
ffc0dcc0: 40 9e 00 10 bne- cr7,ffc0dcd0 <devFS_evaluate_path+0xa0>
continue;
if (device_name_table[i].device_name[pathnamelen] != '\0')
ffc0dcc4: 7c 1c f8 ae lbzx r0,r28,r31
ffc0dcc8: 2f 80 00 00 cmpwi cr7,r0,0
ffc0dccc: 41 9e 00 50 beq- cr7,ffc0dd1c <devFS_evaluate_path+0xec><== ALWAYS TAKEN
/* 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++) {
ffc0dcd0: 7f 9d d0 00 cmpw cr7,r29,r26
ffc0dcd4: 7f a0 eb 78 mr r0,r29
ffc0dcd8: 40 9e ff bc bne+ cr7,ffc0dc94 <devFS_evaluate_path+0x64>
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
return 0;
}
/* no such file or directory */
rtems_set_errno_and_return_minus_one( ENOENT );
ffc0dcdc: 48 00 30 d1 bl ffc10dac <__errno>
ffc0dce0: 38 00 00 02 li r0,2
ffc0dce4: 90 03 00 00 stw r0,0(r3)
ffc0dce8: 38 60 ff ff li r3,-1
}
ffc0dcec: 80 01 00 2c lwz r0,44(r1)
ffc0dcf0: 83 01 00 08 lwz r24,8(r1)
ffc0dcf4: 7c 08 03 a6 mtlr r0
ffc0dcf8: 83 21 00 0c lwz r25,12(r1)
ffc0dcfc: 83 41 00 10 lwz r26,16(r1)
ffc0dd00: 83 61 00 14 lwz r27,20(r1)
ffc0dd04: 83 81 00 18 lwz r28,24(r1)
ffc0dd08: 83 a1 00 1c lwz r29,28(r1)
ffc0dd0c: 83 c1 00 20 lwz r30,32(r1)
ffc0dd10: 83 e1 00 24 lwz r31,36(r1)
ffc0dd14: 38 21 00 28 addi r1,r1,40
ffc0dd18: 4e 80 00 20 blr
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
pathloc->handlers = &devFS_file_handlers;
pathloc->ops = &devFS_ops;
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
ffc0dd1c: 3d 20 00 00 lis r9,0
ffc0dd20: 81 29 27 b4 lwz r9,10164(r9)
if (device_name_table[i].device_name[pathnamelen] != '\0')
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
ffc0dd24: 93 38 00 00 stw r25,0(r24)
pathloc->handlers = &devFS_file_handlers;
pathloc->ops = &devFS_ops;
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
ffc0dd28: 80 09 00 28 lwz r0,40(r9)
if (device_name_table[i].device_name[pathnamelen] != '\0')
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
pathloc->handlers = &devFS_file_handlers;
ffc0dd2c: 3d 20 00 00 lis r9,0
ffc0dd30: 39 29 21 84 addi r9,r9,8580
ffc0dd34: 91 38 00 08 stw r9,8(r24)
pathloc->ops = &devFS_ops;
ffc0dd38: 3d 20 00 00 lis r9,0
ffc0dd3c: 39 29 21 bc addi r9,r9,8636
ffc0dd40: 91 38 00 0c stw r9,12(r24)
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
ffc0dd44: 90 18 00 10 stw r0,16(r24)
return 0;
}
/* no such file or directory */
rtems_set_errno_and_return_minus_one( ENOENT );
}
ffc0dd48: 80 01 00 2c lwz r0,44(r1)
ffc0dd4c: 83 01 00 08 lwz r24,8(r1)
ffc0dd50: 7c 08 03 a6 mtlr r0
ffc0dd54: 83 21 00 0c lwz r25,12(r1)
ffc0dd58: 83 41 00 10 lwz r26,16(r1)
ffc0dd5c: 83 61 00 14 lwz r27,20(r1)
ffc0dd60: 83 81 00 18 lwz r28,24(r1)
ffc0dd64: 83 a1 00 1c lwz r29,28(r1)
ffc0dd68: 83 c1 00 20 lwz r30,32(r1)
ffc0dd6c: 83 e1 00 24 lwz r31,36(r1)
ffc0dd70: 38 21 00 28 addi r1,r1,40
ffc0dd74: 4e 80 00 20 blr
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
rtems_set_errno_and_return_minus_one( EPERM );
ffc0dd78: 48 00 30 35 bl ffc10dac <__errno> <== NOT EXECUTED
ffc0dd7c: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc0dd80: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc0dd84: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc0dd88: 4b ff ff c0 b ffc0dd48 <devFS_evaluate_path+0x118> <== NOT EXECUTED
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
ffc0dd8c: 48 00 30 21 bl ffc10dac <__errno>
ffc0dd90: 38 00 00 0e li r0,14
ffc0dd94: 90 03 00 00 stw r0,0(r3)
ffc0dd98: 38 60 ff ff li r3,-1
ffc0dd9c: 4b ff ff ac b ffc0dd48 <devFS_evaluate_path+0x118>
ffc047c8 <devFS_mknod>:
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
ffc047c8: 94 21 ff d8 stwu r1,-40(r1)
ffc047cc: 7c 08 02 a6 mflr r0
ffc047d0: 93 81 00 18 stw r28,24(r1)
ffc047d4: 7c dc 33 78 mr r28,r6
ffc047d8: 93 a1 00 1c stw r29,28(r1)
ffc047dc: 7c bd 2b 78 mr r29,r5
ffc047e0: 93 c1 00 20 stw r30,32(r1)
ffc047e4: 7c 9e 23 78 mr r30,r4
ffc047e8: 93 e1 00 24 stw r31,36(r1)
ffc047ec: 7c 7f 1b 78 mr r31,r3
ffc047f0: 90 01 00 2c stw r0,44(r1)
ffc047f4: 93 01 00 08 stw r24,8(r1)
ffc047f8: 93 21 00 0c stw r25,12(r1)
ffc047fc: 93 41 00 10 stw r26,16(r1)
ffc04800: 93 61 00 14 stw r27,20(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') &&
ffc04804: 88 03 00 00 lbz r0,0(r3)
ffc04808: 2f 80 00 64 cmpwi cr7,r0,100
ffc0480c: 41 9e 01 40 beq- cr7,ffc0494c <devFS_mknod+0x184>
(path[2] == 'v') && (path[3] == '\0'))
return 0;
/* must be a character device or a block device */
if (!S_ISBLK(mode) && !S_ISCHR(mode))
ffc04810: 57 c0 04 26 rlwinm r0,r30,0,16,19
ffc04814: 2f 80 60 00 cmpwi cr7,r0,24576
ffc04818: 41 9e 00 0c beq- cr7,ffc04824 <devFS_mknod+0x5c>
ffc0481c: 2f 80 20 00 cmpwi cr7,r0,8192
ffc04820: 40 9e 01 58 bne- cr7,ffc04978 <devFS_mknod+0x1b0>
rtems_set_errno_and_return_minus_one( EINVAL );
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;
ffc04824: 83 47 00 00 lwz r26,0(r7)
if (!device_name_table)
ffc04828: 2f 9a 00 00 cmpwi cr7,r26,0
ffc0482c: 41 9e 01 74 beq- cr7,ffc049a0 <devFS_mknod+0x1d8>
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
ffc04830: 3d 20 00 00 lis r9,0
ffc04834: 83 29 27 78 lwz r25,10104(r9)
ffc04838: 2f 99 00 00 cmpwi cr7,r25,0
ffc0483c: 41 9e 01 50 beq- cr7,ffc0498c <devFS_mknod+0x1c4>
ffc04840: 38 00 00 00 li r0,0
#include <stdlib.h>
#include <rtems/seterr.h>
#include "devfs.h"
int devFS_mknod(
ffc04844: 3b 00 ff ff li r24,-1
ffc04848: 3b 60 00 00 li r27,0
ffc0484c: 48 00 00 20 b ffc0486c <devFS_mknod+0xa4>
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
if (device_name_table[i].device_name == NULL)
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
ffc04850: 48 00 d5 fd bl ffc11e4c <strcmp>
ffc04854: 2f 83 00 00 cmpwi cr7,r3,0
ffc04858: 41 9e 00 b4 beq- cr7,ffc0490c <devFS_mknod+0x144>
/* 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++){
ffc0485c: 3b 7b 00 01 addi r27,r27,1
ffc04860: 7f 9b c8 00 cmpw cr7,r27,r25
ffc04864: 7f 60 db 78 mr r0,r27
ffc04868: 41 9e 00 30 beq- cr7,ffc04898 <devFS_mknod+0xd0>
if (device_name_table[i].device_name == NULL)
ffc0486c: 1c 00 00 14 mulli r0,r0,20
ffc04870: 7c 1a 00 2e lwzx r0,r26,r0
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
ffc04874: 7f e3 fb 78 mr r3,r31
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++){
if (device_name_table[i].device_name == NULL)
ffc04878: 2f 80 00 00 cmpwi cr7,r0,0
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
ffc0487c: 7c 04 03 78 mr r4,r0
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++){
if (device_name_table[i].device_name == NULL)
ffc04880: 40 9e ff d0 bne+ cr7,ffc04850 <devFS_mknod+0x88>
ffc04884: 7f 78 db 78 mr r24,r27
/* 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++){
ffc04888: 3b 7b 00 01 addi r27,r27,1
ffc0488c: 7f 9b c8 00 cmpw cr7,r27,r25
ffc04890: 7f 60 db 78 mr r0,r27
ffc04894: 40 9e ff d8 bne+ cr7,ffc0486c <devFS_mknod+0xa4>
else
if (strcmp(path, device_name_table[i].device_name) == 0)
rtems_set_errno_and_return_minus_one( EEXIST );
}
if (slot == -1)
ffc04898: 2f 98 ff ff cmpwi cr7,r24,-1
ffc0489c: 41 9e 00 f0 beq- cr7,ffc0498c <devFS_mknod+0x1c4> <== NEVER TAKEN
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc048a0: 7f 60 00 a6 mfmsr r27
ffc048a4: 7c 10 42 a6 mfsprg r0,0
ffc048a8: 7f 60 00 78 andc r0,r27,r0
ffc048ac: 7c 00 01 24 mtmsr r0
rtems_set_errno_and_return_minus_one( ENOMEM );
_ISR_Disable(level);
device_name_table[slot].device_name = (char *)path;
ffc048b0: 1f 18 00 14 mulli r24,r24,20
ffc048b4: 7f fa c1 2e stwx r31,r26,r24
device_name_table[slot].device_name_length = strlen(path);
ffc048b8: 7f e3 fb 78 mr r3,r31
if (slot == -1)
rtems_set_errno_and_return_minus_one( ENOMEM );
_ISR_Disable(level);
device_name_table[slot].device_name = (char *)path;
ffc048bc: 7f 5a c2 14 add r26,r26,r24
device_name_table[slot].device_name_length = strlen(path);
ffc048c0: 48 00 d6 55 bl ffc11f14 <strlen>
device_name_table[slot].major = major;
ffc048c4: 93 ba 00 08 stw r29,8(r26)
if (slot == -1)
rtems_set_errno_and_return_minus_one( ENOMEM );
_ISR_Disable(level);
device_name_table[slot].device_name = (char *)path;
device_name_table[slot].device_name_length = strlen(path);
ffc048c8: 90 7a 00 04 stw r3,4(r26)
device_name_table[slot].major = major;
device_name_table[slot].minor = minor;
ffc048cc: 93 9a 00 0c stw r28,12(r26)
device_name_table[slot].mode = mode;
ffc048d0: 93 da 00 10 stw r30,16(r26)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc048d4: 7f 60 01 24 mtmsr r27
_ISR_Enable(level);
return 0;
ffc048d8: 38 60 00 00 li r3,0
}
ffc048dc: 80 01 00 2c lwz r0,44(r1)
ffc048e0: 83 01 00 08 lwz r24,8(r1)
ffc048e4: 7c 08 03 a6 mtlr r0
ffc048e8: 83 21 00 0c lwz r25,12(r1)
ffc048ec: 83 41 00 10 lwz r26,16(r1)
ffc048f0: 83 61 00 14 lwz r27,20(r1)
ffc048f4: 83 81 00 18 lwz r28,24(r1)
ffc048f8: 83 a1 00 1c lwz r29,28(r1)
ffc048fc: 83 c1 00 20 lwz r30,32(r1)
ffc04900: 83 e1 00 24 lwz r31,36(r1)
ffc04904: 38 21 00 28 addi r1,r1,40
ffc04908: 4e 80 00 20 blr
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
if (device_name_table[i].device_name == NULL)
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
rtems_set_errno_and_return_minus_one( EEXIST );
ffc0490c: 48 00 c4 a1 bl ffc10dac <__errno>
ffc04910: 38 00 00 11 li r0,17
ffc04914: 90 03 00 00 stw r0,0(r3)
ffc04918: 38 60 ff ff li r3,-1
device_name_table[slot].minor = minor;
device_name_table[slot].mode = mode;
_ISR_Enable(level);
return 0;
}
ffc0491c: 80 01 00 2c lwz r0,44(r1)
ffc04920: 83 01 00 08 lwz r24,8(r1)
ffc04924: 7c 08 03 a6 mtlr r0
ffc04928: 83 21 00 0c lwz r25,12(r1)
ffc0492c: 83 41 00 10 lwz r26,16(r1)
ffc04930: 83 61 00 14 lwz r27,20(r1)
ffc04934: 83 81 00 18 lwz r28,24(r1)
ffc04938: 83 a1 00 1c lwz r29,28(r1)
ffc0493c: 83 c1 00 20 lwz r30,32(r1)
ffc04940: 83 e1 00 24 lwz r31,36(r1)
ffc04944: 38 21 00 28 addi r1,r1,40
ffc04948: 4e 80 00 20 blr
* 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') &&
ffc0494c: 88 03 00 01 lbz r0,1(r3)
ffc04950: 2f 80 00 65 cmpwi cr7,r0,101
ffc04954: 40 9e fe bc bne+ cr7,ffc04810 <devFS_mknod+0x48> <== NEVER TAKEN
ffc04958: 88 03 00 02 lbz r0,2(r3)
ffc0495c: 2f 80 00 76 cmpwi cr7,r0,118
ffc04960: 40 9e fe b0 bne+ cr7,ffc04810 <devFS_mknod+0x48> <== NEVER TAKEN
(path[2] == 'v') && (path[3] == '\0'))
ffc04964: 88 03 00 03 lbz r0,3(r3)
return 0;
ffc04968: 38 60 00 00 li r3,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'))
ffc0496c: 2f 80 00 00 cmpwi cr7,r0,0
ffc04970: 40 9e fe a0 bne+ cr7,ffc04810 <devFS_mknod+0x48>
ffc04974: 4b ff ff 68 b ffc048dc <devFS_mknod+0x114>
return 0;
/* must be a character device or a block device */
if (!S_ISBLK(mode) && !S_ISCHR(mode))
rtems_set_errno_and_return_minus_one( EINVAL );
ffc04978: 48 00 c4 35 bl ffc10dac <__errno>
ffc0497c: 38 00 00 16 li r0,22
ffc04980: 90 03 00 00 stw r0,0(r3)
ffc04984: 38 60 ff ff li r3,-1
ffc04988: 4b ff ff 54 b ffc048dc <devFS_mknod+0x114>
if (strcmp(path, device_name_table[i].device_name) == 0)
rtems_set_errno_and_return_minus_one( EEXIST );
}
if (slot == -1)
rtems_set_errno_and_return_minus_one( ENOMEM );
ffc0498c: 48 00 c4 21 bl ffc10dac <__errno>
ffc04990: 38 00 00 0c li r0,12
ffc04994: 90 03 00 00 stw r0,0(r3)
ffc04998: 38 60 ff ff li r3,-1
ffc0499c: 4b ff ff 40 b ffc048dc <devFS_mknod+0x114>
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 );
ffc049a0: 48 00 c4 0d bl ffc10dac <__errno>
ffc049a4: 38 00 00 0e li r0,14
ffc049a8: 90 03 00 00 stw r0,0(r3)
ffc049ac: 38 60 ff ff li r3,-1
ffc049b0: 4b ff ff 2c b ffc048dc <devFS_mknod+0x114>
ffc04458 <disk_lock>:
*/
static volatile bool diskdevs_protected;
static rtems_status_code
disk_lock(void)
{
ffc04458: 94 21 ff f0 stwu r1,-16(r1)
ffc0445c: 7c 08 02 a6 mflr r0
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_semaphore_obtain(diskdevs_mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
ffc04460: 38 80 00 00 li r4,0
*/
static volatile bool diskdevs_protected;
static rtems_status_code
disk_lock(void)
{
ffc04464: 90 01 00 14 stw r0,20(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_semaphore_obtain(diskdevs_mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
ffc04468: 38 a0 00 00 li r5,0
*/
static volatile bool diskdevs_protected;
static rtems_status_code
disk_lock(void)
{
ffc0446c: 93 e1 00 0c stw r31,12(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_semaphore_obtain(diskdevs_mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
ffc04470: 3f e0 00 00 lis r31,0
ffc04474: 3b ff 28 e8 addi r31,r31,10472
ffc04478: 80 7f 00 08 lwz r3,8(r31)
ffc0447c: 48 00 5d 19 bl ffc0a194 <rtems_semaphore_obtain>
if (sc == RTEMS_SUCCESSFUL) {
ffc04480: 2f 83 00 00 cmpwi cr7,r3,0
diskdevs_protected = true;
return RTEMS_SUCCESSFUL;
} else {
return RTEMS_NOT_CONFIGURED;
ffc04484: 38 60 00 16 li r3,22
disk_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_semaphore_obtain(diskdevs_mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc == RTEMS_SUCCESSFUL) {
ffc04488: 41 9e 00 18 beq- cr7,ffc044a0 <disk_lock+0x48> <== ALWAYS TAKEN
return RTEMS_SUCCESSFUL;
} else {
return RTEMS_NOT_CONFIGURED;
}
}
ffc0448c: 80 01 00 14 lwz r0,20(r1) <== NOT EXECUTED
ffc04490: 83 e1 00 0c lwz r31,12(r1) <== NOT EXECUTED
ffc04494: 38 21 00 10 addi r1,r1,16 <== NOT EXECUTED
ffc04498: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc0449c: 4e 80 00 20 blr <== NOT EXECUTED
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_semaphore_obtain(diskdevs_mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc == RTEMS_SUCCESSFUL) {
diskdevs_protected = true;
ffc044a0: 38 00 00 01 li r0,1
ffc044a4: 98 1f 00 0c stb r0,12(r31)
return RTEMS_SUCCESSFUL;
ffc044a8: 38 60 00 00 li r3,0
} else {
return RTEMS_NOT_CONFIGURED;
}
}
ffc044ac: 80 01 00 14 lwz r0,20(r1)
ffc044b0: 83 e1 00 0c lwz r31,12(r1)
ffc044b4: 38 21 00 10 addi r1,r1,16
ffc044b8: 7c 08 03 a6 mtlr r0
ffc044bc: 4e 80 00 20 blr
ffc044c0 <disk_unlock>:
static void
disk_unlock(void)
{
ffc044c0: 94 21 ff f8 stwu r1,-8(r1)
ffc044c4: 7c 08 02 a6 mflr r0
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
ffc044c8: 3d 20 00 00 lis r9,0
}
}
static void
disk_unlock(void)
{
ffc044cc: 90 01 00 0c stw r0,12(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
ffc044d0: 39 29 28 e8 addi r9,r9,10472
ffc044d4: 38 00 00 00 li r0,0
sc = rtems_semaphore_release(diskdevs_mutex);
ffc044d8: 80 69 00 08 lwz r3,8(r9)
static void
disk_unlock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
ffc044dc: 98 09 00 0c stb r0,12(r9)
sc = rtems_semaphore_release(diskdevs_mutex);
ffc044e0: 48 00 5e 41 bl ffc0a320 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL) {
ffc044e4: 2f 83 00 00 cmpwi cr7,r3,0
ffc044e8: 40 9e 00 14 bne- cr7,ffc044fc <disk_unlock+0x3c> <== NEVER TAKEN
/* FIXME: Error number */
rtems_fatal_error_occurred(0xdeadbeef);
}
}
ffc044ec: 80 01 00 0c lwz r0,12(r1)
ffc044f0: 38 21 00 08 addi r1,r1,8
ffc044f4: 7c 08 03 a6 mtlr r0
ffc044f8: 4e 80 00 20 blr
diskdevs_protected = false;
sc = rtems_semaphore_release(diskdevs_mutex);
if (sc != RTEMS_SUCCESSFUL) {
/* FIXME: Error number */
rtems_fatal_error_occurred(0xdeadbeef);
ffc044fc: 3c 60 de ad lis r3,-8531 <== NOT EXECUTED
ffc04500: 60 63 be ef ori r3,r3,48879 <== NOT EXECUTED
ffc04504: 48 00 65 ad bl ffc0aab0 <rtems_fatal_error_occurred> <== NOT EXECUTED
ffc06568 <drainOutput.part.0>:
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
ffc06568: 94 21 ff f0 stwu r1,-16(r1)
ffc0656c: 7c 08 02 a6 mflr r0
ffc06570: 90 01 00 14 stw r0,20(r1)
ffc06574: 93 e1 00 0c stw r31,12(r1)
ffc06578: 7c 7f 1b 78 mr r31,r3
ffc0657c: 93 c1 00 08 stw r30,8(r1)
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc06580: 7c 00 00 a6 mfmsr r0
ffc06584: 7d 30 42 a6 mfsprg r9,0
ffc06588: 7c 09 48 78 andc r9,r0,r9
ffc0658c: 7d 20 01 24 mtmsr r9
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) {
ffc06590: 81 63 00 84 lwz r11,132(r3)
ffc06594: 81 23 00 80 lwz r9,128(r3)
ffc06598: 7f 8b 48 00 cmpw cr7,r11,r9
ffc0659c: 41 9e 00 48 beq- cr7,ffc065e4 <drainOutput.part.0+0x7c> <== ALWAYS TAKEN
tty->rawOutBufState = rob_wait;
ffc065a0: 3b c0 00 02 li r30,2 <== NOT EXECUTED
ffc065a4: 93 df 00 94 stw r30,148(r31) <== NOT EXECUTED
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc065a8: 7c 00 01 24 mtmsr r0 <== NOT EXECUTED
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
ffc065ac: 80 7f 00 8c lwz r3,140(r31) <== NOT EXECUTED
ffc065b0: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc065b4: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc065b8: 48 00 2e 21 bl ffc093d8 <rtems_semaphore_obtain> <== NOT EXECUTED
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc065bc: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc065c0: 40 9e 00 40 bne- cr7,ffc06600 <drainOutput.part.0+0x98> <== NOT EXECUTED
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc065c4: 7c 00 00 a6 mfmsr r0 <== NOT EXECUTED
ffc065c8: 7d 30 42 a6 mfsprg r9,0 <== NOT EXECUTED
ffc065cc: 7c 09 48 78 andc r9,r0,r9 <== NOT EXECUTED
ffc065d0: 7d 20 01 24 mtmsr r9 <== 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) {
ffc065d4: 81 7f 00 84 lwz r11,132(r31) <== NOT EXECUTED
ffc065d8: 81 3f 00 80 lwz r9,128(r31) <== NOT EXECUTED
ffc065dc: 7f 8b 48 00 cmpw cr7,r11,r9 <== NOT EXECUTED
ffc065e0: 40 9e ff c4 bne+ cr7,ffc065a4 <drainOutput.part.0+0x3c> <== NOT EXECUTED
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc065e4: 7c 00 01 24 mtmsr r0
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
rtems_interrupt_enable (level);
}
}
ffc065e8: 80 01 00 14 lwz r0,20(r1)
ffc065ec: 83 c1 00 08 lwz r30,8(r1)
ffc065f0: 7c 08 03 a6 mtlr r0
ffc065f4: 83 e1 00 0c lwz r31,12(r1)
ffc065f8: 38 21 00 10 addi r1,r1,16
ffc065fc: 4e 80 00 20 blr
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
ffc06600: 48 00 37 41 bl ffc09d40 <rtems_fatal_error_occurred> <== NOT EXECUTED
ffc0743c <echo>:
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
ffc0743c: 94 21 ff e0 stwu r1,-32(r1)
ffc07440: 7c 08 02 a6 mflr r0
ffc07444: 90 01 00 24 stw r0,36(r1)
if ((tty->termios.c_lflag & ECHOCTL) &&
ffc07448: 81 24 00 3c lwz r9,60(r4)
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
ffc0744c: 93 e1 00 1c stw r31,28(r1)
ffc07450: 7c 9f 23 78 mr r31,r4
if ((tty->termios.c_lflag & ECHOCTL) &&
ffc07454: 71 20 02 00 andi. r0,r9,512
ffc07458: 41 82 00 2c beq- ffc07484 <echo+0x48> <== NEVER TAKEN
iscntrl(c) && (c != '\t') && (c != '\n')) {
ffc0745c: 3d 20 00 00 lis r9,0
ffc07460: 81 29 27 84 lwz r9,10116(r9)
ffc07464: 7d 29 1a 14 add r9,r9,r3
ffc07468: 88 09 00 01 lbz r0,1(r9)
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
if ((tty->termios.c_lflag & ECHOCTL) &&
ffc0746c: 70 09 00 20 andi. r9,r0,32
ffc07470: 41 82 00 14 beq- ffc07484 <echo+0x48>
iscntrl(c) && (c != '\t') && (c != '\n')) {
ffc07474: 2f 83 00 09 cmpwi cr7,r3,9
ffc07478: 41 9e 00 0c beq- cr7,ffc07484 <echo+0x48>
ffc0747c: 2f 83 00 0a cmpwi cr7,r3,10
ffc07480: 40 9e 00 20 bne- cr7,ffc074a0 <echo+0x64>
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
tty->column += 2;
} else {
oproc (c, tty);
ffc07484: 7f e4 fb 78 mr r4,r31
ffc07488: 4b ff fe 29 bl ffc072b0 <oproc>
}
}
ffc0748c: 80 01 00 24 lwz r0,36(r1)
ffc07490: 83 e1 00 1c lwz r31,28(r1)
ffc07494: 38 21 00 20 addi r1,r1,32
ffc07498: 7c 08 03 a6 mtlr r0
ffc0749c: 4e 80 00 20 blr
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
ffc074a0: 68 60 00 40 xori r0,r3,64
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
ffc074a4: 39 20 00 5e li r9,94
echobuf[1] = c ^ 0x40;
ffc074a8: 98 01 00 09 stb r0,9(r1)
rtems_termios_puts (echobuf, 2, tty);
ffc074ac: 38 61 00 08 addi r3,r1,8
ffc074b0: 7f e5 fb 78 mr r5,r31
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
ffc074b4: 99 21 00 08 stb r9,8(r1)
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
ffc074b8: 38 80 00 02 li r4,2
ffc074bc: 4b ff fc 45 bl ffc07100 <rtems_termios_puts>
tty->column += 2;
ffc074c0: 81 3f 00 28 lwz r9,40(r31)
ffc074c4: 38 09 00 02 addi r0,r9,2
ffc074c8: 90 1f 00 28 stw r0,40(r31)
} else {
oproc (c, tty);
}
}
ffc074cc: 80 01 00 24 lwz r0,36(r1)
ffc074d0: 83 e1 00 1c lwz r31,28(r1)
ffc074d4: 38 21 00 20 addi r1,r1,32
ffc074d8: 7c 08 03 a6 mtlr r0
ffc074dc: 4e 80 00 20 blr
ffc06158 <endgrent>:
void endgrent(void)
{
if (group_fp != NULL)
ffc06158: 3d 20 00 00 lis r9,0
fclose(group_fp);
group_fp = fopen("/etc/group", "r");
}
void endgrent(void)
{
ffc0615c: 94 21 ff f8 stwu r1,-8(r1)
ffc06160: 7c 08 02 a6 mflr r0
if (group_fp != NULL)
ffc06164: 80 69 2a 94 lwz r3,10900(r9)
fclose(group_fp);
group_fp = fopen("/etc/group", "r");
}
void endgrent(void)
{
ffc06168: 90 01 00 0c stw r0,12(r1)
if (group_fp != NULL)
ffc0616c: 2f 83 00 00 cmpwi cr7,r3,0
ffc06170: 41 9e 00 08 beq- cr7,ffc06178 <endgrent+0x20> <== NEVER TAKEN
fclose(group_fp);
ffc06174: 48 00 ea fd bl ffc14c70 <fclose>
}
ffc06178: 80 01 00 0c lwz r0,12(r1)
ffc0617c: 38 21 00 08 addi r1,r1,8
ffc06180: 7c 08 03 a6 mtlr r0
ffc06184: 4e 80 00 20 blr
ffc05f8c <endpwent>:
void endpwent(void)
{
if (passwd_fp != NULL)
ffc05f8c: 3d 20 00 00 lis r9,0
fclose(passwd_fp);
passwd_fp = fopen("/etc/passwd", "r");
}
void endpwent(void)
{
ffc05f90: 94 21 ff f8 stwu r1,-8(r1)
ffc05f94: 7c 08 02 a6 mflr r0
if (passwd_fp != NULL)
ffc05f98: 80 69 29 b8 lwz r3,10680(r9)
fclose(passwd_fp);
passwd_fp = fopen("/etc/passwd", "r");
}
void endpwent(void)
{
ffc05f9c: 90 01 00 0c stw r0,12(r1)
if (passwd_fp != NULL)
ffc05fa0: 2f 83 00 00 cmpwi cr7,r3,0
ffc05fa4: 41 9e 00 08 beq- cr7,ffc05fac <endpwent+0x20> <== NEVER TAKEN
fclose(passwd_fp);
ffc05fa8: 48 00 ec c9 bl ffc14c70 <fclose>
}
ffc05fac: 80 01 00 0c lwz r0,12(r1)
ffc05fb0: 38 21 00 08 addi r1,r1,8
ffc05fb4: 7c 08 03 a6 mtlr r0
ffc05fb8: 4e 80 00 20 blr
ffc074e0 <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)
{
ffc074e0: 94 21 ff d8 stwu r1,-40(r1)
ffc074e4: 7c 08 02 a6 mflr r0
ffc074e8: 7d 80 00 26 mfcr r12
ffc074ec: 90 01 00 2c stw r0,44(r1)
if (tty->ccount == 0)
ffc074f0: 81 23 00 20 lwz r9,32(r3)
* 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)
{
ffc074f4: 93 e1 00 24 stw r31,36(r1)
ffc074f8: 7c 7f 1b 78 mr r31,r3
if (tty->ccount == 0)
ffc074fc: 2f 89 00 00 cmpwi cr7,r9,0
* FIXME: Needs support for WERASE and ECHOPRT.
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
ffc07500: 93 41 00 10 stw r26,16(r1)
ffc07504: 93 61 00 14 stw r27,20(r1)
ffc07508: 93 81 00 18 stw r28,24(r1)
ffc0750c: 93 a1 00 1c stw r29,28(r1)
ffc07510: 93 c1 00 20 stw r30,32(r1)
ffc07514: 91 81 00 0c stw r12,12(r1)
if (tty->ccount == 0)
ffc07518: 41 9e 00 9c beq- cr7,ffc075b4 <erase+0xd4>
return;
if (lineFlag) {
ffc0751c: 2e 04 00 00 cmpwi cr4,r4,0
if (!(tty->termios.c_lflag & ECHO)) {
ffc07520: 80 03 00 3c lwz r0,60(r3)
ffc07524: 54 0b 07 38 rlwinm r11,r0,0,28,28
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
return;
if (lineFlag) {
ffc07528: 40 92 00 80 bne- cr4,ffc075a8 <erase+0xc8>
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
ffc0752c: 3f 60 ff c2 lis r27,-62
ffc07530: 3f a0 ff c2 lis r29,-62
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
ffc07534: 3f 80 00 00 lis r28,0
rtems_termios_puts ("\b \b", 3, tty);
ffc07538: 3b 7b 0c 38 addi r27,r27,3128
ffc0753c: 3b bd 0c 34 addi r29,r29,3124
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
ffc07540: 2f 8b 00 00 cmpwi cr7,r11,0
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
ffc07544: 81 5f 00 1c lwz r10,28(r31)
ffc07548: 39 29 ff ff addi r9,r9,-1
ffc0754c: 91 3f 00 20 stw r9,32(r31)
ffc07550: 7f ca 48 ae lbzx r30,r10,r9
if (tty->termios.c_lflag & ECHO) {
ffc07554: 41 9e 00 38 beq- cr7,ffc0758c <erase+0xac> <== NEVER TAKEN
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
ffc07558: 40 92 00 0c bne- cr4,ffc07564 <erase+0x84>
ffc0755c: 70 0b 00 10 andi. r11,r0,16
ffc07560: 41 82 01 e4 beq- ffc07744 <erase+0x264> <== NEVER TAKEN
echo (tty->termios.c_cc[VERASE], tty);
} else if (c == '\t') {
ffc07564: 2f 9e 00 09 cmpwi cr7,r30,9
ffc07568: 41 9e 00 e4 beq- cr7,ffc0764c <erase+0x16c>
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
ffc0756c: 81 3c 27 84 lwz r9,10116(r28)
ffc07570: 3b de 00 01 addi r30,r30,1
ffc07574: 7f 7a db 78 mr r26,r27
ffc07578: 7d 29 f0 ae lbzx r9,r9,r30
ffc0757c: 71 2b 00 20 andi. r11,r9,32
ffc07580: 41 82 00 a4 beq- ffc07624 <erase+0x144> <== ALWAYS TAKEN
ffc07584: 70 09 02 00 andi. r9,r0,512 <== NOT EXECUTED
ffc07588: 40 82 00 5c bne- ffc075e4 <erase+0x104> <== NOT EXECUTED
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
ffc0758c: 41 92 00 28 beq- cr4,ffc075b4 <erase+0xd4>
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
ffc07590: 81 3f 00 20 lwz r9,32(r31)
ffc07594: 2f 89 00 00 cmpwi cr7,r9,0
ffc07598: 41 9e 00 1c beq- cr7,ffc075b4 <erase+0xd4>
}
if (!(tty->termios.c_lflag & ECHOE)) {
tty->ccount = 0;
echo (tty->termios.c_cc[VKILL], tty);
if (tty->termios.c_lflag & ECHOK)
echo ('\n', tty);
ffc0759c: 80 1f 00 3c lwz r0,60(r31)
ffc075a0: 54 0b 07 38 rlwinm r11,r0,0,28,28
ffc075a4: 4b ff ff 9c b ffc07540 <erase+0x60>
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
return;
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
ffc075a8: 70 0b 00 08 andi. r11,r0,8
ffc075ac: 40 a2 01 3c bne+ ffc076e8 <erase+0x208> <== ALWAYS TAKEN
tty->ccount = 0;
ffc075b0: 91 63 00 20 stw r11,32(r3) <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
ffc075b4: 80 01 00 2c lwz r0,44(r1)
ffc075b8: 81 81 00 0c lwz r12,12(r1)
ffc075bc: 7c 08 03 a6 mtlr r0
ffc075c0: 83 41 00 10 lwz r26,16(r1)
ffc075c4: 83 61 00 14 lwz r27,20(r1)
ffc075c8: 7d 80 81 20 mtcrf 8,r12
ffc075cc: 83 81 00 18 lwz r28,24(r1)
ffc075d0: 83 a1 00 1c lwz r29,28(r1)
ffc075d4: 83 c1 00 20 lwz r30,32(r1)
ffc075d8: 83 e1 00 24 lwz r31,36(r1)
ffc075dc: 38 21 00 28 addi r1,r1,40
ffc075e0: 4e 80 00 20 blr
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
ffc075e4: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc075e8: 38 80 00 03 li r4,3 <== NOT EXECUTED
ffc075ec: 7f e5 fb 78 mr r5,r31 <== NOT EXECUTED
ffc075f0: 4b ff fb 11 bl ffc07100 <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
ffc075f4: 81 3f 00 28 lwz r9,40(r31) <== NOT EXECUTED
ffc075f8: 2f 89 00 00 cmpwi cr7,r9,0 <== NOT EXECUTED
ffc075fc: 41 9e 00 0c beq- cr7,ffc07608 <erase+0x128> <== NOT EXECUTED
tty->column--;
ffc07600: 39 29 ff ff addi r9,r9,-1 <== NOT EXECUTED
ffc07604: 91 3f 00 28 stw r9,40(r31) <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
ffc07608: 81 3c 27 84 lwz r9,10116(r28) <== NOT EXECUTED
ffc0760c: 7c 09 f0 ae lbzx r0,r9,r30 <== NOT EXECUTED
ffc07610: 70 0b 00 20 andi. r11,r0,32 <== NOT EXECUTED
ffc07614: 41 82 00 10 beq- ffc07624 <erase+0x144> <== NOT EXECUTED
ffc07618: 80 1f 00 3c lwz r0,60(r31) <== NOT EXECUTED
ffc0761c: 70 09 02 00 andi. r9,r0,512 <== NOT EXECUTED
ffc07620: 41 a2 ff 6c beq- ffc0758c <erase+0xac> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
ffc07624: 7f 43 d3 78 mr r3,r26
ffc07628: 38 80 00 03 li r4,3
ffc0762c: 7f e5 fb 78 mr r5,r31
ffc07630: 4b ff fa d1 bl ffc07100 <rtems_termios_puts>
if (tty->column)
ffc07634: 81 3f 00 28 lwz r9,40(r31)
ffc07638: 2f 89 00 00 cmpwi cr7,r9,0
ffc0763c: 41 be ff 50 beq- cr7,ffc0758c <erase+0xac> <== NEVER TAKEN
tty->column--;
ffc07640: 39 29 ff ff addi r9,r9,-1
ffc07644: 91 3f 00 28 stw r9,40(r31)
ffc07648: 4b ff ff 44 b ffc0758c <erase+0xac>
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
ffc0764c: 2f 89 00 00 cmpwi cr7,r9,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;
ffc07650: 83 df 00 2c lwz r30,44(r31)
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
ffc07654: 41 9e 00 44 beq- cr7,ffc07698 <erase+0x1b8>
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
if (tty->termios.c_lflag & ECHOCTL)
ffc07658: 7d 29 03 a6 mtctr r9
ffc0765c: 54 0b bf fe rlwinm r11,r0,23,31,31
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
ffc07660: 81 1c 27 84 lwz r8,10116(r28)
if (tty->termios.c_lflag & ECHOCTL)
ffc07664: 2f 0b 00 00 cmpwi cr6,r11,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;
ffc07668: 39 60 00 00 li r11,0
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
ffc0766c: 7c 0a 58 ae lbzx r0,r10,r11
ffc07670: 39 6b 00 01 addi r11,r11,1
if (c == '\t') {
ffc07674: 2f 80 00 09 cmpwi cr7,r0,9
col = (col | 7) + 1;
} else if (iscntrl (c)) {
ffc07678: 7d 28 02 14 add r9,r8,r0
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
ffc0767c: 41 9e 00 5c beq- cr7,ffc076d8 <erase+0x1f8>
col = (col | 7) + 1;
} else if (iscntrl (c)) {
ffc07680: 88 09 00 01 lbz r0,1(r9)
ffc07684: 70 09 00 20 andi. r9,r0,32
ffc07688: 41 82 00 44 beq- ffc076cc <erase+0x1ec> <== ALWAYS TAKEN
if (tty->termios.c_lflag & ECHOCTL)
ffc0768c: 41 9a 00 08 beq- cr6,ffc07694 <erase+0x1b4> <== NOT EXECUTED
col += 2;
ffc07690: 3b de 00 02 addi r30,r30,2 <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
ffc07694: 42 00 ff d8 bdnz+ ffc0766c <erase+0x18c> <== NOT EXECUTED
}
/*
* Back up over the tab
*/
while (tty->column > col) {
ffc07698: 80 1f 00 28 lwz r0,40(r31)
ffc0769c: 7f 9e 00 00 cmpw cr7,r30,r0
ffc076a0: 40 bc fe ec bge- cr7,ffc0758c <erase+0xac> <== NEVER TAKEN
rtems_termios_puts ("\b", 1, tty);
ffc076a4: 7f a3 eb 78 mr r3,r29
ffc076a8: 38 80 00 01 li r4,1
ffc076ac: 7f e5 fb 78 mr r5,r31
ffc076b0: 4b ff fa 51 bl ffc07100 <rtems_termios_puts>
tty->column--;
ffc076b4: 81 3f 00 28 lwz r9,40(r31)
ffc076b8: 38 09 ff ff addi r0,r9,-1
}
/*
* Back up over the tab
*/
while (tty->column > col) {
ffc076bc: 7f 80 f0 00 cmpw cr7,r0,r30
rtems_termios_puts ("\b", 1, tty);
tty->column--;
ffc076c0: 90 1f 00 28 stw r0,40(r31)
}
/*
* Back up over the tab
*/
while (tty->column > col) {
ffc076c4: 41 9d ff e0 bgt+ cr7,ffc076a4 <erase+0x1c4>
ffc076c8: 4b ff fe c4 b ffc0758c <erase+0xac>
col = (col | 7) + 1;
} else if (iscntrl (c)) {
if (tty->termios.c_lflag & ECHOCTL)
col += 2;
} else {
col++;
ffc076cc: 3b de 00 01 addi r30,r30,1
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
ffc076d0: 42 00 ff 9c bdnz+ ffc0766c <erase+0x18c>
ffc076d4: 4b ff ff c4 b ffc07698 <erase+0x1b8>
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
ffc076d8: 63 de 00 07 ori r30,r30,7
ffc076dc: 3b de 00 01 addi r30,r30,1
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
ffc076e0: 42 00 ff 8c bdnz+ ffc0766c <erase+0x18c>
ffc076e4: 4b ff ff b4 b ffc07698 <erase+0x1b8> <== NOT EXECUTED
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
tty->ccount = 0;
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
ffc076e8: 70 0a 00 10 andi. r10,r0,16
ffc076ec: 40 82 fe 40 bne+ ffc0752c <erase+0x4c> <== ALWAYS TAKEN
tty->ccount = 0;
ffc076f0: 91 43 00 20 stw r10,32(r3) <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
ffc076f4: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc076f8: 88 63 00 44 lbz r3,68(r3) <== NOT EXECUTED
ffc076fc: 4b ff fd 41 bl ffc0743c <echo> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
ffc07700: 80 1f 00 3c lwz r0,60(r31) <== NOT EXECUTED
echo ('\n', tty);
ffc07704: 38 60 00 0a li r3,10 <== NOT EXECUTED
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
tty->ccount = 0;
echo (tty->termios.c_cc[VKILL], tty);
if (tty->termios.c_lflag & ECHOK)
ffc07708: 70 09 00 20 andi. r9,r0,32 <== NOT EXECUTED
ffc0770c: 41 82 fe a8 beq+ ffc075b4 <erase+0xd4> <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
ffc07710: 80 01 00 2c lwz r0,44(r1) <== NOT EXECUTED
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
ffc07714: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
ffc07718: 81 81 00 0c lwz r12,12(r1) <== NOT EXECUTED
ffc0771c: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc07720: 83 41 00 10 lwz r26,16(r1) <== NOT EXECUTED
ffc07724: 83 61 00 14 lwz r27,20(r1) <== NOT EXECUTED
ffc07728: 7d 80 81 20 mtcrf 8,r12 <== NOT EXECUTED
ffc0772c: 83 81 00 18 lwz r28,24(r1) <== NOT EXECUTED
ffc07730: 83 a1 00 1c lwz r29,28(r1) <== NOT EXECUTED
ffc07734: 83 c1 00 20 lwz r30,32(r1) <== NOT EXECUTED
ffc07738: 83 e1 00 24 lwz r31,36(r1) <== NOT EXECUTED
ffc0773c: 38 21 00 28 addi r1,r1,40 <== NOT EXECUTED
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
ffc07740: 4b ff fc fc b ffc0743c <echo> <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
ffc07744: 80 01 00 2c lwz r0,44(r1) <== NOT EXECUTED
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
ffc07748: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
ffc0774c: 81 81 00 0c lwz r12,12(r1) <== NOT EXECUTED
ffc07750: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
ffc07754: 88 7f 00 43 lbz r3,67(r31) <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
ffc07758: 83 41 00 10 lwz r26,16(r1) <== NOT EXECUTED
ffc0775c: 7d 80 81 20 mtcrf 8,r12 <== NOT EXECUTED
ffc07760: 83 61 00 14 lwz r27,20(r1) <== NOT EXECUTED
ffc07764: 83 81 00 18 lwz r28,24(r1) <== NOT EXECUTED
ffc07768: 83 a1 00 1c lwz r29,28(r1) <== NOT EXECUTED
ffc0776c: 83 c1 00 20 lwz r30,32(r1) <== NOT EXECUTED
ffc07770: 83 e1 00 24 lwz r31,36(r1) <== NOT EXECUTED
ffc07774: 38 21 00 28 addi r1,r1,40 <== NOT EXECUTED
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
ffc07778: 4b ff fc c4 b ffc0743c <echo> <== NOT EXECUTED
ffc182b8 <fat_buf_access>:
#include "fat_fat_operations.h"
int
fat_buf_access(fat_fs_info_t *fs_info, uint32_t blk, int op_type,
rtems_bdbuf_buffer **buf)
{
ffc182b8: 94 21 ff d0 stwu r1,-48(r1)
ffc182bc: 7c 08 02 a6 mflr r0
ffc182c0: 7d 80 00 26 mfcr r12
ffc182c4: 93 61 00 1c stw r27,28(r1)
ffc182c8: 7c db 33 78 mr r27,r6
ffc182cc: 93 81 00 20 stw r28,32(r1)
ffc182d0: 7c bc 2b 78 mr r28,r5
ffc182d4: 93 a1 00 24 stw r29,36(r1)
ffc182d8: 7c 9d 23 78 mr r29,r4
ffc182dc: 93 e1 00 2c stw r31,44(r1)
ffc182e0: 7c 7f 1b 78 mr r31,r3
ffc182e4: 90 01 00 34 stw r0,52(r1)
ffc182e8: 93 c1 00 28 stw r30,40(r1)
ffc182ec: 91 81 00 18 stw r12,24(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
uint8_t i;
bool sec_of_fat;
if (fs_info->c.state == FAT_CACHE_EMPTY)
ffc182f0: 88 03 00 85 lbz r0,133(r3)
ffc182f4: 2f 80 00 00 cmpwi cr7,r0,0
ffc182f8: 41 9e 01 70 beq- cr7,ffc18468 <fat_buf_access+0x1b0>
ffc182fc: 80 03 00 80 lwz r0,128(r3)
fs_info->c.blk_num = blk;
fs_info->c.modified = 0;
fs_info->c.state = FAT_CACHE_ACTUAL;
}
sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
ffc18300: 39 20 00 00 li r9,0
ffc18304: a1 7f 00 14 lhz r11,20(r31)
ffc18308: 7f 8b 00 40 cmplw cr7,r11,r0
ffc1830c: 40 9d 01 a4 ble- cr7,ffc184b0 <fat_buf_access+0x1f8> <== ALWAYS TAKEN
(fs_info->c.blk_num < fs_info->vol.rdir_loc));
if (fs_info->c.blk_num != blk)
ffc18310: 7f 9d 00 00 cmpw cr7,r29,r0
ffc18314: 41 9e 01 1c beq- cr7,ffc18430 <fat_buf_access+0x178>
{
if (fs_info->c.modified)
ffc18318: 8b df 00 84 lbz r30,132(r31)
ffc1831c: 2f 9e 00 00 cmpwi cr7,r30,0
ffc18320: 41 9e 00 cc beq- cr7,ffc183ec <fat_buf_access+0x134>
{
if (sec_of_fat && !fs_info->vol.mirror)
ffc18324: 2e 09 00 00 cmpwi cr4,r9,0
ffc18328: 41 92 00 10 beq- cr4,ffc18338 <fat_buf_access+0x80> <== ALWAYS TAKEN
ffc1832c: 88 1f 00 48 lbz r0,72(r31) <== NOT EXECUTED
ffc18330: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc18334: 41 9e 01 98 beq- cr7,ffc184cc <fat_buf_access+0x214> <== NOT EXECUTED
memcpy(fs_info->sec_buf, fs_info->c.buf->buffer,
fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
ffc18338: 80 7f 00 88 lwz r3,136(r31)
ffc1833c: 4b ff e1 d5 bl ffc16510 <rtems_bdbuf_release_modified>
fs_info->c.state = FAT_CACHE_EMPTY;
ffc18340: 38 00 00 00 li r0,0
fs_info->c.modified = 0;
if (sc != RTEMS_SUCCESSFUL)
ffc18344: 2f 83 00 00 cmpwi cr7,r3,0
if (sec_of_fat && !fs_info->vol.mirror)
memcpy(fs_info->sec_buf, fs_info->c.buf->buffer,
fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
fs_info->c.state = FAT_CACHE_EMPTY;
ffc18348: 98 1f 00 85 stb r0,133(r31)
fs_info->c.modified = 0;
ffc1834c: 98 1f 00 84 stb r0,132(r31)
if (sc != RTEMS_SUCCESSFUL)
ffc18350: 40 9e 01 9c bne- cr7,ffc184ec <fat_buf_access+0x234> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one(EIO);
if (sec_of_fat && !fs_info->vol.mirror)
ffc18354: 41 92 00 ac beq- cr4,ffc18400 <fat_buf_access+0x148> <== ALWAYS TAKEN
ffc18358: 88 1f 00 48 lbz r0,72(r31) <== NOT EXECUTED
ffc1835c: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc18360: 40 9e 00 a0 bne- cr7,ffc18400 <fat_buf_access+0x148> <== NOT EXECUTED
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
ffc18364: 88 1f 00 09 lbz r0,9(r31) <== NOT EXECUTED
ffc18368: 2b 80 00 01 cmplwi cr7,r0,1 <== NOT EXECUTED
ffc1836c: 40 9d 00 94 ble- cr7,ffc18400 <fat_buf_access+0x148> <== NOT EXECUTED
ffc18370: 3b c0 00 01 li r30,1 <== NOT EXECUTED
ffc18374: 48 00 00 3c b ffc183b0 <fat_buf_access+0xf8> <== NOT EXECUTED
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
ffc18378: 81 21 00 08 lwz r9,8(r1) <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
ffc1837c: 3b de 00 01 addi r30,r30,1 <== NOT EXECUTED
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
ffc18380: 80 9f 00 8c lwz r4,140(r31) <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
ffc18384: 57 de 06 3e clrlwi r30,r30,24 <== NOT EXECUTED
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
ffc18388: a0 bf 00 00 lhz r5,0(r31) <== NOT EXECUTED
ffc1838c: 80 69 00 24 lwz r3,36(r9) <== NOT EXECUTED
ffc18390: 48 00 cc b5 bl ffc25044 <memcpy> <== NOT EXECUTED
sc = rtems_bdbuf_release_modified(b);
ffc18394: 80 61 00 08 lwz r3,8(r1) <== NOT EXECUTED
ffc18398: 4b ff e1 79 bl ffc16510 <rtems_bdbuf_release_modified><== NOT EXECUTED
if ( sc != RTEMS_SUCCESSFUL)
ffc1839c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc183a0: 40 9e 00 38 bne- cr7,ffc183d8 <fat_buf_access+0x120> <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
ffc183a4: 88 1f 00 09 lbz r0,9(r31) <== NOT EXECUTED
ffc183a8: 7f 80 f0 40 cmplw cr7,r0,r30 <== NOT EXECUTED
ffc183ac: 40 9d 00 54 ble- cr7,ffc18400 <fat_buf_access+0x148> <== NOT EXECUTED
{
sc = rtems_bdbuf_get(fs_info->vol.dev,
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
ffc183b0: 80 bf 00 18 lwz r5,24(r31) <== NOT EXECUTED
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
{
sc = rtems_bdbuf_get(fs_info->vol.dev,
ffc183b4: 38 c1 00 08 addi r6,r1,8 <== NOT EXECUTED
ffc183b8: 80 1f 00 80 lwz r0,128(r31) <== NOT EXECUTED
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
ffc183bc: 7c be 29 d6 mullw r5,r30,r5 <== NOT EXECUTED
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
{
sc = rtems_bdbuf_get(fs_info->vol.dev,
ffc183c0: 80 7f 00 58 lwz r3,88(r31) <== NOT EXECUTED
ffc183c4: 80 9f 00 5c lwz r4,92(r31) <== NOT EXECUTED
ffc183c8: 7c a5 02 14 add r5,r5,r0 <== NOT EXECUTED
ffc183cc: 4b ff db bd bl ffc15f88 <rtems_bdbuf_get> <== NOT EXECUTED
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
ffc183d0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc183d4: 41 9e ff a4 beq+ cr7,ffc18378 <fat_buf_access+0xc0> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(b);
if ( sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(ENOMEM);
ffc183d8: 48 00 be 39 bl ffc24210 <__errno> <== NOT EXECUTED
ffc183dc: 38 00 00 0c li r0,12 <== NOT EXECUTED
ffc183e0: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc183e4: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc183e8: 48 00 00 54 b ffc1843c <fat_buf_access+0x184> <== NOT EXECUTED
}
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
ffc183ec: 80 7f 00 88 lwz r3,136(r31)
ffc183f0: 4b ff e0 19 bl ffc16408 <rtems_bdbuf_release>
fs_info->c.state = FAT_CACHE_EMPTY;
ffc183f4: 9b df 00 85 stb r30,133(r31)
if (sc != RTEMS_SUCCESSFUL)
ffc183f8: 2f 83 00 00 cmpwi cr7,r3,0
ffc183fc: 40 9e 00 f0 bne- cr7,ffc184ec <fat_buf_access+0x234> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one(EIO);
}
if (op_type == FAT_OP_TYPE_READ)
ffc18400: 2f 9c 00 01 cmpwi cr7,r28,1
sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
ffc18404: 80 7f 00 58 lwz r3,88(r31)
ffc18408: 80 9f 00 5c lwz r4,92(r31)
ffc1840c: 7f a5 eb 78 mr r5,r29
ffc18410: 38 df 00 88 addi r6,r31,136
fs_info->c.state = FAT_CACHE_EMPTY;
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
}
if (op_type == FAT_OP_TYPE_READ)
ffc18414: 41 9e 00 d0 beq- cr7,ffc184e4 <fat_buf_access+0x22c>
sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
else
sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
ffc18418: 4b ff db 71 bl ffc15f88 <rtems_bdbuf_get>
if (sc != RTEMS_SUCCESSFUL)
ffc1841c: 2f 83 00 00 cmpwi cr7,r3,0
ffc18420: 40 9e 00 cc bne- cr7,ffc184ec <fat_buf_access+0x234> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.blk_num = blk;
fs_info->c.state = FAT_CACHE_ACTUAL;
ffc18424: 38 00 00 01 li r0,1
sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
else
sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.blk_num = blk;
ffc18428: 93 bf 00 80 stw r29,128(r31)
fs_info->c.state = FAT_CACHE_ACTUAL;
ffc1842c: 98 1f 00 85 stb r0,133(r31)
}
*buf = fs_info->c.buf;
ffc18430: 80 1f 00 88 lwz r0,136(r31)
return RC_OK;
ffc18434: 38 60 00 00 li r3,0
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.blk_num = blk;
fs_info->c.state = FAT_CACHE_ACTUAL;
}
*buf = fs_info->c.buf;
ffc18438: 90 1b 00 00 stw r0,0(r27)
return RC_OK;
}
ffc1843c: 80 01 00 34 lwz r0,52(r1)
ffc18440: 81 81 00 18 lwz r12,24(r1)
ffc18444: 7c 08 03 a6 mtlr r0
ffc18448: 83 61 00 1c lwz r27,28(r1)
ffc1844c: 83 81 00 20 lwz r28,32(r1)
ffc18450: 7d 80 81 20 mtcrf 8,r12
ffc18454: 83 a1 00 24 lwz r29,36(r1)
ffc18458: 83 c1 00 28 lwz r30,40(r1)
ffc1845c: 83 e1 00 2c lwz r31,44(r1)
ffc18460: 38 21 00 30 addi r1,r1,48
ffc18464: 4e 80 00 20 blr
bool sec_of_fat;
if (fs_info->c.state == FAT_CACHE_EMPTY)
{
if (op_type == FAT_OP_TYPE_READ)
ffc18468: 2f 9c 00 01 cmpwi cr7,r28,1
sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
ffc1846c: 80 63 00 58 lwz r3,88(r3)
ffc18470: 80 9f 00 5c lwz r4,92(r31)
ffc18474: 7f a5 eb 78 mr r5,r29
ffc18478: 38 df 00 88 addi r6,r31,136
bool sec_of_fat;
if (fs_info->c.state == FAT_CACHE_EMPTY)
{
if (op_type == FAT_OP_TYPE_READ)
ffc1847c: 41 9e 00 48 beq- cr7,ffc184c4 <fat_buf_access+0x20c>
sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
else
sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
ffc18480: 4b ff db 09 bl ffc15f88 <rtems_bdbuf_get>
if (sc != RTEMS_SUCCESSFUL)
ffc18484: 2f 83 00 00 cmpwi cr7,r3,0
ffc18488: 40 9e 00 64 bne- cr7,ffc184ec <fat_buf_access+0x234> <== NEVER TAKEN
fs_info->c.blk_num = blk;
fs_info->c.modified = 0;
fs_info->c.state = FAT_CACHE_ACTUAL;
}
sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
ffc1848c: a1 7f 00 14 lhz r11,20(r31)
sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.blk_num = blk;
fs_info->c.modified = 0;
fs_info->c.state = FAT_CACHE_ACTUAL;
ffc18490: 7f a0 eb 78 mr r0,r29
ffc18494: 39 20 00 01 li r9,1
sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
else
sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.blk_num = blk;
ffc18498: 93 bf 00 80 stw r29,128(r31)
fs_info->c.modified = 0;
fs_info->c.state = FAT_CACHE_ACTUAL;
}
sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
ffc1849c: 7f 8b 00 40 cmplw cr7,r11,r0
sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.blk_num = blk;
fs_info->c.modified = 0;
fs_info->c.state = FAT_CACHE_ACTUAL;
ffc184a0: 99 3f 00 85 stb r9,133(r31)
}
sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
ffc184a4: 39 20 00 00 li r9,0
else
sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.blk_num = blk;
fs_info->c.modified = 0;
ffc184a8: 98 7f 00 84 stb r3,132(r31)
fs_info->c.state = FAT_CACHE_ACTUAL;
}
sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
ffc184ac: 41 bd fe 64 bgt- cr7,ffc18310 <fat_buf_access+0x58> <== NEVER TAKEN
ffc184b0: 81 3f 00 1c lwz r9,28(r31)
ffc184b4: 7d 29 00 10 subfc r9,r9,r0
ffc184b8: 7d 29 49 10 subfe r9,r9,r9
ffc184bc: 7d 29 00 d0 neg r9,r9
ffc184c0: 4b ff fe 50 b ffc18310 <fat_buf_access+0x58>
if (fs_info->c.state == FAT_CACHE_EMPTY)
{
if (op_type == FAT_OP_TYPE_READ)
sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
ffc184c4: 4b ff db e9 bl ffc160ac <rtems_bdbuf_read>
ffc184c8: 4b ff ff bc b ffc18484 <fat_buf_access+0x1cc>
if (fs_info->c.blk_num != blk)
{
if (fs_info->c.modified)
{
if (sec_of_fat && !fs_info->vol.mirror)
memcpy(fs_info->sec_buf, fs_info->c.buf->buffer,
ffc184cc: 81 3f 00 88 lwz r9,136(r31) <== NOT EXECUTED
ffc184d0: 80 7f 00 8c lwz r3,140(r31) <== NOT EXECUTED
ffc184d4: 80 89 00 24 lwz r4,36(r9) <== NOT EXECUTED
ffc184d8: a0 bf 00 00 lhz r5,0(r31) <== NOT EXECUTED
ffc184dc: 48 00 cb 69 bl ffc25044 <memcpy> <== NOT EXECUTED
ffc184e0: 4b ff fe 58 b ffc18338 <fat_buf_access+0x80> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
}
if (op_type == FAT_OP_TYPE_READ)
sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
ffc184e4: 4b ff db c9 bl ffc160ac <rtems_bdbuf_read>
ffc184e8: 4b ff ff 34 b ffc1841c <fat_buf_access+0x164>
else
sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
ffc184ec: 48 00 bd 25 bl ffc24210 <__errno> <== NOT EXECUTED
ffc184f0: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc184f4: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc184f8: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc184fc: 4b ff ff 40 b ffc1843c <fat_buf_access+0x184> <== NOT EXECUTED
ffc18500 <fat_buf_release>:
return RC_OK;
}
int
fat_buf_release(fat_fs_info_t *fs_info)
{
ffc18500: 94 21 ff d8 stwu r1,-40(r1)
ffc18504: 7c 08 02 a6 mflr r0
ffc18508: 7d 80 00 26 mfcr r12
ffc1850c: 93 e1 00 24 stw r31,36(r1)
ffc18510: 7c 7f 1b 78 mr r31,r3
ffc18514: 90 01 00 2c stw r0,44(r1)
ffc18518: 93 c1 00 20 stw r30,32(r1)
ffc1851c: 91 81 00 1c stw r12,28(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
uint8_t i;
bool sec_of_fat;
if (fs_info->c.state == FAT_CACHE_EMPTY)
ffc18520: 88 03 00 85 lbz r0,133(r3)
return RC_OK;
ffc18524: 38 60 00 00 li r3,0
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
uint8_t i;
bool sec_of_fat;
if (fs_info->c.state == FAT_CACHE_EMPTY)
ffc18528: 2f 80 00 00 cmpwi cr7,r0,0
ffc1852c: 41 9e 00 f0 beq- cr7,ffc1861c <fat_buf_release+0x11c>
return RC_OK;
sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
ffc18530: 81 3f 00 80 lwz r9,128(r31)
ffc18534: 38 00 00 00 li r0,0
ffc18538: a1 7f 00 14 lhz r11,20(r31)
ffc1853c: 7f 89 58 40 cmplw cr7,r9,r11
ffc18540: 41 9c 00 14 blt- cr7,ffc18554 <fat_buf_release+0x54> <== NEVER TAKEN
*buf = fs_info->c.buf;
return RC_OK;
}
int
fat_buf_release(fat_fs_info_t *fs_info)
ffc18544: 80 1f 00 1c lwz r0,28(r31)
ffc18548: 7c 00 48 10 subfc r0,r0,r9
ffc1854c: 7c 00 01 10 subfe r0,r0,r0
ffc18550: 7c 00 00 d0 neg r0,r0
return RC_OK;
sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
(fs_info->c.blk_num < fs_info->vol.rdir_loc));
if (fs_info->c.modified)
ffc18554: 89 3f 00 84 lbz r9,132(r31)
ffc18558: 2f 89 00 00 cmpwi cr7,r9,0
ffc1855c: 41 9e 00 e0 beq- cr7,ffc1863c <fat_buf_release+0x13c>
{
if (sec_of_fat && !fs_info->vol.mirror)
ffc18560: 2e 00 00 00 cmpwi cr4,r0,0
ffc18564: 41 92 00 10 beq- cr4,ffc18574 <fat_buf_release+0x74>
ffc18568: 88 1f 00 48 lbz r0,72(r31)
ffc1856c: 2f 80 00 00 cmpwi cr7,r0,0
ffc18570: 41 9e 01 08 beq- cr7,ffc18678 <fat_buf_release+0x178> <== ALWAYS TAKEN
memcpy(fs_info->sec_buf, fs_info->c.buf->buffer, fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
ffc18574: 80 7f 00 88 lwz r3,136(r31)
ffc18578: 4b ff df 99 bl ffc16510 <rtems_bdbuf_release_modified>
if (sc != RTEMS_SUCCESSFUL)
ffc1857c: 2c 03 00 00 cmpwi r3,0
ffc18580: 40 82 01 10 bne- ffc18690 <fat_buf_release+0x190> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.modified = 0;
ffc18584: 98 7f 00 84 stb r3,132(r31)
if (sec_of_fat && !fs_info->vol.mirror)
ffc18588: 41 92 00 c4 beq- cr4,ffc1864c <fat_buf_release+0x14c>
ffc1858c: 88 1f 00 48 lbz r0,72(r31)
ffc18590: 2f 80 00 00 cmpwi cr7,r0,0
ffc18594: 40 9e 00 b8 bne- cr7,ffc1864c <fat_buf_release+0x14c> <== NEVER TAKEN
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
ffc18598: 88 1f 00 09 lbz r0,9(r31)
ffc1859c: 2b 80 00 01 cmplwi cr7,r0,1
ffc185a0: 40 9d 00 ac ble- cr7,ffc1864c <fat_buf_release+0x14c> <== NEVER TAKEN
ffc185a4: 3b c0 00 01 li r30,1
ffc185a8: 48 00 00 3c b ffc185e4 <fat_buf_release+0xe4>
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
ffc185ac: 81 21 00 08 lwz r9,8(r1)
if (sec_of_fat && !fs_info->vol.mirror)
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
ffc185b0: 3b de 00 01 addi r30,r30,1
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
ffc185b4: 80 9f 00 8c lwz r4,140(r31)
if (sec_of_fat && !fs_info->vol.mirror)
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
ffc185b8: 57 de 06 3e clrlwi r30,r30,24
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
ffc185bc: a0 bf 00 00 lhz r5,0(r31)
ffc185c0: 80 69 00 24 lwz r3,36(r9)
ffc185c4: 48 00 ca 81 bl ffc25044 <memcpy>
sc = rtems_bdbuf_release_modified(b);
ffc185c8: 80 61 00 08 lwz r3,8(r1)
ffc185cc: 4b ff df 45 bl ffc16510 <rtems_bdbuf_release_modified>
if ( sc != RTEMS_SUCCESSFUL)
ffc185d0: 2f 83 00 00 cmpwi cr7,r3,0
ffc185d4: 40 9e 00 38 bne- cr7,ffc1860c <fat_buf_release+0x10c> <== NEVER TAKEN
if (sec_of_fat && !fs_info->vol.mirror)
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
ffc185d8: 88 1f 00 09 lbz r0,9(r31)
ffc185dc: 7f 80 f0 40 cmplw cr7,r0,r30
ffc185e0: 40 9d 00 6c ble- cr7,ffc1864c <fat_buf_release+0x14c> <== ALWAYS TAKEN
{
sc = rtems_bdbuf_get(fs_info->vol.dev,
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
ffc185e4: 80 bf 00 18 lwz r5,24(r31)
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
{
sc = rtems_bdbuf_get(fs_info->vol.dev,
ffc185e8: 38 c1 00 08 addi r6,r1,8
ffc185ec: 80 1f 00 80 lwz r0,128(r31)
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
ffc185f0: 7c be 29 d6 mullw r5,r30,r5
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
{
sc = rtems_bdbuf_get(fs_info->vol.dev,
ffc185f4: 80 7f 00 58 lwz r3,88(r31)
ffc185f8: 80 9f 00 5c lwz r4,92(r31)
ffc185fc: 7c a5 02 14 add r5,r5,r0
ffc18600: 4b ff d9 89 bl ffc15f88 <rtems_bdbuf_get>
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
ffc18604: 2f 83 00 00 cmpwi cr7,r3,0
ffc18608: 41 9e ff a4 beq+ cr7,ffc185ac <fat_buf_release+0xac> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(b);
if ( sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(ENOMEM);
ffc1860c: 48 00 bc 05 bl ffc24210 <__errno> <== NOT EXECUTED
ffc18610: 38 00 00 0c li r0,12 <== NOT EXECUTED
ffc18614: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc18618: 38 60 ff ff li r3,-1 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
}
fs_info->c.state = FAT_CACHE_EMPTY;
return RC_OK;
}
ffc1861c: 80 01 00 2c lwz r0,44(r1)
ffc18620: 81 81 00 1c lwz r12,28(r1)
ffc18624: 7c 08 03 a6 mtlr r0
ffc18628: 83 c1 00 20 lwz r30,32(r1)
ffc1862c: 83 e1 00 24 lwz r31,36(r1)
ffc18630: 7d 80 81 20 mtcrf 8,r12
ffc18634: 38 21 00 28 addi r1,r1,40
ffc18638: 4e 80 00 20 blr
}
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
ffc1863c: 80 7f 00 88 lwz r3,136(r31)
ffc18640: 4b ff dd c9 bl ffc16408 <rtems_bdbuf_release>
if (sc != RTEMS_SUCCESSFUL)
ffc18644: 2f 83 00 00 cmpwi cr7,r3,0
ffc18648: 40 9e 00 48 bne- cr7,ffc18690 <fat_buf_release+0x190> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one(EIO);
}
fs_info->c.state = FAT_CACHE_EMPTY;
ffc1864c: 38 00 00 00 li r0,0
ffc18650: 98 1f 00 85 stb r0,133(r31)
return RC_OK;
ffc18654: 38 60 00 00 li r3,0
}
ffc18658: 80 01 00 2c lwz r0,44(r1)
ffc1865c: 81 81 00 1c lwz r12,28(r1)
ffc18660: 7c 08 03 a6 mtlr r0
ffc18664: 83 c1 00 20 lwz r30,32(r1)
ffc18668: 83 e1 00 24 lwz r31,36(r1)
ffc1866c: 7d 80 81 20 mtcrf 8,r12
ffc18670: 38 21 00 28 addi r1,r1,40
ffc18674: 4e 80 00 20 blr
(fs_info->c.blk_num < fs_info->vol.rdir_loc));
if (fs_info->c.modified)
{
if (sec_of_fat && !fs_info->vol.mirror)
memcpy(fs_info->sec_buf, fs_info->c.buf->buffer, fs_info->vol.bps);
ffc18678: 81 3f 00 88 lwz r9,136(r31)
ffc1867c: 80 7f 00 8c lwz r3,140(r31)
ffc18680: 80 89 00 24 lwz r4,36(r9)
ffc18684: a0 bf 00 00 lhz r5,0(r31)
ffc18688: 48 00 c9 bd bl ffc25044 <memcpy>
ffc1868c: 4b ff fe e8 b ffc18574 <fat_buf_release+0x74>
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
ffc18690: 48 00 bb 81 bl ffc24210 <__errno> <== NOT EXECUTED
ffc18694: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc18698: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1869c: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc186a0: 4b ff ff 7c b ffc1861c <fat_buf_release+0x11c> <== NOT EXECUTED
ffc188b0 <fat_cluster_read>:
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
ffc188b0: 2c 04 00 00 cmpwi r4,0 <== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
void *buff
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc188b4: 81 23 00 34 lwz r9,52(r3) <== NOT EXECUTED
fat_cluster_read(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
void *buff
)
{
ffc188b8: 7c a7 2b 78 mr r7,r5 <== NOT EXECUTED
ffc188bc: 40 82 00 10 bne- ffc188cc <fat_cluster_read+0x1c> <== NOT EXECUTED
ffc188c0: 88 09 00 0a lbz r0,10(r9) <== NOT EXECUTED
ffc188c4: 70 0b 00 03 andi. r11,r0,3 <== NOT EXECUTED
ffc188c8: 40 82 00 2c bne- ffc188f4 <fat_cluster_read+0x44> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
ffc188cc: 89 69 00 05 lbz r11,5(r9) <== NOT EXECUTED
ffc188d0: 38 84 ff fe addi r4,r4,-2 <== NOT EXECUTED
ffc188d4: 80 09 00 30 lwz r0,48(r9) <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t fsec = 0;
fsec = fat_cluster_num_to_sector_num(mt_entry, cln);
return _fat_block_read(mt_entry, fsec, 0,
ffc188d8: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc188dc: 7c 84 58 30 slw r4,r4,r11 <== NOT EXECUTED
fs_info->vol.spc << fs_info->vol.sec_log2, buff);
ffc188e0: 88 c9 00 04 lbz r6,4(r9) <== NOT EXECUTED
ffc188e4: 7c 84 02 14 add r4,r4,r0 <== NOT EXECUTED
ffc188e8: 88 09 00 02 lbz r0,2(r9) <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t fsec = 0;
fsec = fat_cluster_num_to_sector_num(mt_entry, cln);
return _fat_block_read(mt_entry, fsec, 0,
ffc188ec: 7c c6 00 30 slw r6,r6,r0 <== NOT EXECUTED
ffc188f0: 4b ff fd b4 b ffc186a4 <_fat_block_read> <== NOT EXECUTED
fs_info->vol.spc << fs_info->vol.sec_log2, buff);
ffc188f4: 88 c9 00 04 lbz r6,4(r9) <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t fsec = 0;
fsec = fat_cluster_num_to_sector_num(mt_entry, cln);
return _fat_block_read(mt_entry, fsec, 0,
ffc188f8: 38 a0 00 00 li r5,0 <== NOT EXECUTED
fs_info->vol.spc << fs_info->vol.sec_log2, buff);
ffc188fc: 88 09 00 02 lbz r0,2(r9) <== NOT EXECUTED
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
return fs_info->vol.rdir_loc;
ffc18900: 80 89 00 1c lwz r4,28(r9) <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t fsec = 0;
fsec = fat_cluster_num_to_sector_num(mt_entry, cln);
return _fat_block_read(mt_entry, fsec, 0,
ffc18904: 7c c6 00 30 slw r6,r6,r0 <== NOT EXECUTED
ffc18908: 4b ff fd 9c b ffc186a4 <_fat_block_read> <== NOT EXECUTED
ffc1890c <fat_cluster_write>:
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
ffc1890c: 2c 04 00 00 cmpwi r4,0
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
const void *buff
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc18910: 81 23 00 34 lwz r9,52(r3)
fat_cluster_write(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
const void *buff
)
{
ffc18914: 7c a7 2b 78 mr r7,r5
ffc18918: 40 82 00 10 bne- ffc18928 <fat_cluster_write+0x1c> <== ALWAYS TAKEN
ffc1891c: 88 09 00 0a lbz r0,10(r9) <== NOT EXECUTED
ffc18920: 70 0b 00 03 andi. r11,r0,3 <== NOT EXECUTED
ffc18924: 40 82 00 2c bne- ffc18950 <fat_cluster_write+0x44> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
ffc18928: 89 69 00 05 lbz r11,5(r9)
ffc1892c: 38 84 ff fe addi r4,r4,-2
ffc18930: 80 09 00 30 lwz r0,48(r9)
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t fsec = 0;
fsec = fat_cluster_num_to_sector_num(mt_entry, cln);
return _fat_block_write(mt_entry, fsec, 0,
ffc18934: 38 a0 00 00 li r5,0
ffc18938: 7c 84 58 30 slw r4,r4,r11
fs_info->vol.spc << fs_info->vol.sec_log2, buff);
ffc1893c: 88 c9 00 04 lbz r6,4(r9)
ffc18940: 7c 84 02 14 add r4,r4,r0
ffc18944: 88 09 00 02 lbz r0,2(r9)
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t fsec = 0;
fsec = fat_cluster_num_to_sector_num(mt_entry, cln);
return _fat_block_write(mt_entry, fsec, 0,
ffc18948: 7c c6 00 30 slw r6,r6,r0
ffc1894c: 4b ff fe 38 b ffc18784 <_fat_block_write>
fs_info->vol.spc << fs_info->vol.sec_log2, buff);
ffc18950: 88 c9 00 04 lbz r6,4(r9) <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t fsec = 0;
fsec = fat_cluster_num_to_sector_num(mt_entry, cln);
return _fat_block_write(mt_entry, fsec, 0,
ffc18954: 38 a0 00 00 li r5,0 <== NOT EXECUTED
fs_info->vol.spc << fs_info->vol.sec_log2, buff);
ffc18958: 88 09 00 02 lbz r0,2(r9) <== NOT EXECUTED
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
return fs_info->vol.rdir_loc;
ffc1895c: 80 89 00 1c lwz r4,28(r9) <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t fsec = 0;
fsec = fat_cluster_num_to_sector_num(mt_entry, cln);
return _fat_block_write(mt_entry, fsec, 0,
ffc18960: 7c c6 00 30 slw r6,r6,r0 <== NOT EXECUTED
ffc18964: 4b ff fe 20 b ffc18784 <_fat_block_write> <== NOT EXECUTED
ffc18c04 <fat_fat32_update_fsinfo_sector>:
fat_fat32_update_fsinfo_sector(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t free_count,
uint32_t next_free
)
{
ffc18c04: 94 21 ff d8 stwu r1,-40(r1) <== NOT EXECUTED
ffc18c08: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc18c0c: 90 01 00 2c stw r0,44(r1) <== NOT EXECUTED
ffc18c10: 93 c1 00 20 stw r30,32(r1) <== NOT EXECUTED
ffc18c14: 7c 7e 1b 78 mr r30,r3 <== NOT EXECUTED
ffc18c18: 93 e1 00 24 stw r31,36(r1) <== NOT EXECUTED
ffc18c1c: 93 a1 00 1c stw r29,28(r1) <== NOT EXECUTED
ssize_t ret1 = 0, ret2 = 0;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc18c20: 83 e3 00 34 lwz r31,52(r3) <== NOT EXECUTED
uint32_t value
)
{
uint32_t swapped;
__asm__ volatile("rlwimi %0,%1,8,24,31;"
ffc18c24: 50 80 46 3e rlwimi r0,r4,8,24,31 <== NOT EXECUTED
ffc18c28: 50 80 c4 2e rlwimi r0,r4,24,16,23 <== NOT EXECUTED
ffc18c2c: 50 80 42 1e rlwimi r0,r4,8,8,15 <== NOT EXECUTED
ffc18c30: 50 80 c0 0e rlwimi r0,r4,24,0,7 <== NOT EXECUTED
uint32_t le_free_count = 0;
uint32_t le_next_free = 0;
le_free_count = CT_LE_L(free_count);
ffc18c34: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
ffc18c38: 50 a0 46 3e rlwimi r0,r5,8,24,31 <== NOT EXECUTED
ffc18c3c: 50 a0 c4 2e rlwimi r0,r5,24,16,23 <== NOT EXECUTED
ffc18c40: 50 a0 42 1e rlwimi r0,r5,8,8,15 <== NOT EXECUTED
ffc18c44: 50 a0 c0 0e rlwimi r0,r5,24,0,7 <== NOT EXECUTED
le_next_free = CT_LE_L(next_free);
ret1 = _fat_block_write(mt_entry,
ffc18c48: a0 9f 00 3c lhz r4,60(r31) <== NOT EXECUTED
ffc18c4c: 38 a0 01 e8 li r5,488 <== NOT EXECUTED
ffc18c50: 38 c0 00 04 li r6,4 <== NOT EXECUTED
register fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t le_free_count = 0;
uint32_t le_next_free = 0;
le_free_count = CT_LE_L(free_count);
le_next_free = CT_LE_L(next_free);
ffc18c54: 90 01 00 08 stw r0,8(r1) <== NOT EXECUTED
ret1 = _fat_block_write(mt_entry,
ffc18c58: 38 e1 00 0c addi r7,r1,12 <== NOT EXECUTED
ffc18c5c: 4b ff fb 29 bl ffc18784 <_fat_block_write> <== NOT EXECUTED
fs_info->vol.info_sec,
FAT_FSINFO_FREE_CLUSTER_COUNT_OFFSET,
4,
(char *)(&le_free_count));
ret2 = _fat_block_write(mt_entry,
ffc18c60: a0 9f 00 3c lhz r4,60(r31) <== NOT EXECUTED
uint32_t le_next_free = 0;
le_free_count = CT_LE_L(free_count);
le_next_free = CT_LE_L(next_free);
ret1 = _fat_block_write(mt_entry,
ffc18c64: 7c 7d 1b 78 mr r29,r3 <== NOT EXECUTED
fs_info->vol.info_sec,
FAT_FSINFO_FREE_CLUSTER_COUNT_OFFSET,
4,
(char *)(&le_free_count));
ret2 = _fat_block_write(mt_entry,
ffc18c68: 38 a0 01 ec li r5,492 <== NOT EXECUTED
ffc18c6c: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc18c70: 38 c0 00 04 li r6,4 <== NOT EXECUTED
ffc18c74: 38 e1 00 08 addi r7,r1,8 <== NOT EXECUTED
ffc18c78: 4b ff fb 0d bl ffc18784 <_fat_block_write> <== NOT EXECUTED
fs_info->vol.info_sec,
FAT_FSINFO_NEXT_FREE_CLUSTER_OFFSET,
4,
(char *)(&le_next_free));
if ( (ret1 < 0) || (ret2 < 0) )
ffc18c7c: 2f 9d 00 00 cmpwi cr7,r29,0 <== NOT EXECUTED
return -1;
ffc18c80: 38 00 ff ff li r0,-1 <== NOT EXECUTED
fs_info->vol.info_sec,
FAT_FSINFO_NEXT_FREE_CLUSTER_OFFSET,
4,
(char *)(&le_next_free));
if ( (ret1 < 0) || (ret2 < 0) )
ffc18c84: 41 9c 00 08 blt- cr7,ffc18c8c <fat_fat32_update_fsinfo_sector+0x88><== NOT EXECUTED
return -1;
ffc18c88: 7c 60 fe 70 srawi r0,r3,31 <== NOT EXECUTED
return RC_OK;
}
ffc18c8c: 7c 03 03 78 mr r3,r0 <== NOT EXECUTED
ffc18c90: 80 01 00 2c lwz r0,44(r1) <== NOT EXECUTED
ffc18c94: 83 a1 00 1c lwz r29,28(r1) <== NOT EXECUTED
ffc18c98: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc18c9c: 83 c1 00 20 lwz r30,32(r1) <== NOT EXECUTED
ffc18ca0: 83 e1 00 24 lwz r31,36(r1) <== NOT EXECUTED
ffc18ca4: 38 21 00 28 addi r1,r1,40 <== NOT EXECUTED
ffc18ca8: 4e 80 00 20 blr <== NOT EXECUTED
ffc17880 <fat_file_close>:
int
fat_file_close(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ffc17880: 94 21 ff e8 stwu r1,-24(r1)
ffc17884: 7c 08 02 a6 mflr r0
ffc17888: 90 01 00 1c stw r0,28(r1)
/*
* if links_num field of fat-file descriptor is greater than 1
* decrement the count of links and return
*/
if (fat_fd->links_num > 1)
ffc1788c: 81 24 00 08 lwz r9,8(r4)
int
fat_file_close(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ffc17890: 93 a1 00 0c stw r29,12(r1)
/*
* if links_num field of fat-file descriptor is greater than 1
* decrement the count of links and return
*/
if (fat_fd->links_num > 1)
ffc17894: 2b 89 00 01 cmplwi cr7,r9,1
int
fat_file_close(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ffc17898: 93 c1 00 10 stw r30,16(r1)
ffc1789c: 7c 7e 1b 78 mr r30,r3
ffc178a0: 93 e1 00 14 stw r31,20(r1)
ffc178a4: 7c 9f 23 78 mr r31,r4
ffc178a8: 93 81 00 08 stw r28,8(r1)
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc178ac: 83 a3 00 34 lwz r29,52(r3)
/*
* if links_num field of fat-file descriptor is greater than 1
* decrement the count of links and return
*/
if (fat_fd->links_num > 1)
ffc178b0: 40 9d 00 30 ble- cr7,ffc178e0 <fat_file_close+0x60>
{
fat_fd->links_num--;
ffc178b4: 39 29 ff ff addi r9,r9,-1
ffc178b8: 91 24 00 08 stw r9,8(r4)
return rc;
ffc178bc: 38 60 00 00 li r3,0
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
return rc;
}
ffc178c0: 80 01 00 1c lwz r0,28(r1)
ffc178c4: 83 81 00 08 lwz r28,8(r1)
ffc178c8: 7c 08 03 a6 mtlr r0
ffc178cc: 83 a1 00 0c lwz r29,12(r1)
ffc178d0: 83 c1 00 10 lwz r30,16(r1)
ffc178d4: 83 e1 00 14 lwz r31,20(r1)
ffc178d8: 38 21 00 18 addi r1,r1,24
ffc178dc: 4e 80 00 20 blr
return rc;
}
key = fat_construct_key(mt_entry, &fat_fd->dir_pos.sname);
if (fat_fd->flags & FAT_FILE_REMOVED)
ffc178e0: 88 04 00 30 lbz r0,48(r4)
ffc178e4: 70 1c 00 01 andi. r28,r0,1
ffc178e8: 41 82 00 3c beq- ffc17924 <fat_file_close+0xa4> <== ALWAYS TAKEN
{
rc = fat_file_truncate(mt_entry, fat_fd, 0);
ffc178ec: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc178f0: 4b ff fe 29 bl ffc17718 <fat_file_truncate> <== NOT EXECUTED
if ( rc != RC_OK )
ffc178f4: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc178f8: 40 82 ff c8 bne+ ffc178c0 <fat_file_close+0x40> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
ffc178fc: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc17900: 4b ff 6e d9 bl ffc0e7d8 <_Chain_Extract> <== NOT EXECUTED
return rc;
_hash_delete(fs_info->rhash, key, fat_fd->ino, fat_fd);
if ( fat_ino_is_unique(mt_entry, fat_fd->ino) )
ffc17904: 80 9f 00 0c lwz r4,12(r31) <== NOT EXECUTED
ffc17908: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1790c: 48 00 12 e1 bl ffc18bec <fat_ino_is_unique> <== NOT EXECUTED
ffc17910: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc17914: 40 9e 00 58 bne- cr7,ffc1796c <fat_file_close+0xec> <== NOT EXECUTED
fat_fd->links_num = 0;
}
else
{
_hash_delete(fs_info->vhash, key, fat_fd->ino, fat_fd);
free(fat_fd);
ffc17918: 7f e3 fb 78 mr r3,r31
ffc1791c: 4b ff 0b c5 bl ffc084e0 <free>
ffc17920: 48 00 00 18 b ffc17938 <fat_file_close+0xb8>
free(fat_fd);
}
else
{
if (fat_ino_is_unique(mt_entry, fat_fd->ino))
ffc17924: 80 84 00 0c lwz r4,12(r4)
ffc17928: 48 00 12 c5 bl ffc18bec <fat_ino_is_unique>
ffc1792c: 2f 83 00 00 cmpwi cr7,r3,0
ffc17930: 41 9e 00 30 beq- cr7,ffc17960 <fat_file_close+0xe0> <== ALWAYS TAKEN
{
fat_fd->links_num = 0;
ffc17934: 93 9f 00 08 stw r28,8(r31) <== NOT EXECUTED
}
}
/*
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
ffc17938: 7f a3 eb 78 mr r3,r29
ffc1793c: 48 00 0b c5 bl ffc18500 <fat_buf_release>
return rc;
}
ffc17940: 80 01 00 1c lwz r0,28(r1)
ffc17944: 83 81 00 08 lwz r28,8(r1)
ffc17948: 7c 08 03 a6 mtlr r0
ffc1794c: 83 a1 00 0c lwz r29,12(r1)
ffc17950: 83 c1 00 10 lwz r30,16(r1)
ffc17954: 83 e1 00 14 lwz r31,20(r1)
ffc17958: 38 21 00 18 addi r1,r1,24
ffc1795c: 4e 80 00 20 blr
ffc17960: 7f e3 fb 78 mr r3,r31
ffc17964: 4b ff 6e 75 bl ffc0e7d8 <_Chain_Extract>
ffc17968: 4b ff ff b0 b ffc17918 <fat_file_close+0x98>
return rc;
_hash_delete(fs_info->rhash, key, fat_fd->ino, fat_fd);
if ( fat_ino_is_unique(mt_entry, fat_fd->ino) )
fat_free_unique_ino(mt_entry, fat_fd->ino);
ffc1796c: 80 9f 00 0c lwz r4,12(r31) <== NOT EXECUTED
ffc17970: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc17974: 48 00 12 49 bl ffc18bbc <fat_free_unique_ino> <== NOT EXECUTED
ffc17978: 4b ff ff a0 b ffc17918 <fat_file_close+0x98> <== NOT EXECUTED
ffc18030 <fat_file_datasync>:
int
fat_file_datasync(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ffc18030: 94 21 ff d0 stwu r1,-48(r1) <== NOT EXECUTED
ffc18034: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc18038: 90 01 00 34 stw r0,52(r1) <== NOT EXECUTED
uint32_t cur_cln = fat_fd->cln;
rtems_bdbuf_buffer *block = NULL;
uint32_t sec = 0;
uint32_t i = 0;
if (fat_fd->fat_file_size == 0)
ffc1803c: 81 24 00 18 lwz r9,24(r4) <== NOT EXECUTED
)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
ffc18040: 80 04 00 1c lwz r0,28(r4) <== NOT EXECUTED
rtems_bdbuf_buffer *block = NULL;
uint32_t sec = 0;
uint32_t i = 0;
if (fat_fd->fat_file_size == 0)
ffc18044: 2f 89 00 00 cmpwi cr7,r9,0 <== NOT EXECUTED
int
fat_file_datasync(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ffc18048: 93 61 00 1c stw r27,28(r1) <== NOT EXECUTED
ffc1804c: 7c 7b 1b 78 mr r27,r3 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
ffc18050: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
rtems_bdbuf_buffer *block = NULL;
ffc18054: 38 00 00 00 li r0,0 <== NOT EXECUTED
int
fat_file_datasync(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ffc18058: 93 81 00 20 stw r28,32(r1) <== NOT EXECUTED
rtems_bdbuf_buffer *block = NULL;
uint32_t sec = 0;
uint32_t i = 0;
if (fat_fd->fat_file_size == 0)
return RC_OK;
ffc1805c: 3b 80 00 00 li r28,0 <== NOT EXECUTED
int
fat_file_datasync(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ffc18060: 93 c1 00 28 stw r30,40(r1) <== NOT EXECUTED
ffc18064: 93 a1 00 24 stw r29,36(r1) <== NOT EXECUTED
ffc18068: 93 e1 00 2c stw r31,44(r1) <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc1806c: 83 c3 00 34 lwz r30,52(r3) <== NOT EXECUTED
uint32_t cur_cln = fat_fd->cln;
rtems_bdbuf_buffer *block = NULL;
ffc18070: 90 01 00 08 stw r0,8(r1) <== NOT EXECUTED
uint32_t sec = 0;
uint32_t i = 0;
if (fat_fd->fat_file_size == 0)
ffc18074: 40 9e 00 2c bne- cr7,ffc180a0 <fat_file_datasync+0x70> <== NOT EXECUTED
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
if ( rc != RC_OK )
return rc;
}
return rc;
}
ffc18078: 80 01 00 34 lwz r0,52(r1) <== NOT EXECUTED
ffc1807c: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc18080: 83 61 00 1c lwz r27,28(r1) <== NOT EXECUTED
ffc18084: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc18088: 83 81 00 20 lwz r28,32(r1) <== NOT EXECUTED
ffc1808c: 83 a1 00 24 lwz r29,36(r1) <== NOT EXECUTED
ffc18090: 83 c1 00 28 lwz r30,40(r1) <== NOT EXECUTED
ffc18094: 83 e1 00 2c lwz r31,44(r1) <== NOT EXECUTED
ffc18098: 38 21 00 30 addi r1,r1,48 <== NOT EXECUTED
ffc1809c: 4e 80 00 20 blr <== NOT EXECUTED
/*
* we can use only one bdbuf :( and we also know that cache is useless
* for sync operation, so don't use it
*/
rc = fat_buf_release(fs_info);
ffc180a0: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc180a4: 48 00 04 5d bl ffc18500 <fat_buf_release> <== NOT EXECUTED
if (rc != RC_OK)
ffc180a8: 7c 7c 1b 79 mr. r28,r3 <== NOT EXECUTED
ffc180ac: 40 a2 ff cc bne- ffc18078 <fat_file_datasync+0x48> <== NOT EXECUTED
return rc;
/* for each cluster of the file ... */
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
ffc180b0: 80 81 00 0c lwz r4,12(r1) <== NOT EXECUTED
ffc180b4: 81 3e 00 0c lwz r9,12(r30) <== NOT EXECUTED
ffc180b8: 80 1e 00 10 lwz r0,16(r30) <== NOT EXECUTED
ffc180bc: 7c 89 48 38 and r9,r4,r9 <== NOT EXECUTED
ffc180c0: 7f 89 00 40 cmplw cr7,r9,r0 <== NOT EXECUTED
ffc180c4: 40 bc ff b4 bge- cr7,ffc18078 <fat_file_datasync+0x48> <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
ffc180c8: 2f 84 00 00 cmpwi cr7,r4,0 <== NOT EXECUTED
fat_fd->map.disk_cln = cur_cln;
*disk_cln = cur_cln;
}
return RC_OK;
}
ffc180cc: 81 3b 00 34 lwz r9,52(r27) <== NOT EXECUTED
ffc180d0: 41 9e 00 a0 beq- cr7,ffc18170 <fat_file_datasync+0x140> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
ffc180d4: 89 69 00 05 lbz r11,5(r9) <== NOT EXECUTED
ffc180d8: 3b a4 ff fe addi r29,r4,-2 <== NOT EXECUTED
ffc180dc: 80 09 00 30 lwz r0,48(r9) <== NOT EXECUTED
ffc180e0: 7f bd 58 30 slw r29,r29,r11 <== NOT EXECUTED
ffc180e4: 7f bd 02 14 add r29,r29,r0 <== NOT EXECUTED
/* for each cluster of the file ... */
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
/* for each sector in cluster ... */
for ( i = 0; i < fs_info->vol.spc; i++ )
ffc180e8: 88 1e 00 04 lbz r0,4(r30) <== NOT EXECUTED
ffc180ec: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc180f0: 41 9e 00 98 beq- cr7,ffc18188 <fat_file_datasync+0x158> <== NOT EXECUTED
ffc180f4: 3b e0 00 00 li r31,0 <== NOT EXECUTED
ffc180f8: 48 00 00 20 b ffc18118 <fat_file_datasync+0xe8> <== NOT EXECUTED
/* ... sync it */
sc = rtems_bdbuf_read(fs_info->vol.dev, (sec + i), &block);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one( EIO );
sc = rtems_bdbuf_sync(block);
ffc180fc: 80 61 00 08 lwz r3,8(r1) <== NOT EXECUTED
ffc18100: 4b ff e4 b9 bl ffc165b8 <rtems_bdbuf_sync> <== NOT EXECUTED
if ( sc != RTEMS_SUCCESSFUL )
ffc18104: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc18108: 40 9e 00 30 bne- cr7,ffc18138 <fat_file_datasync+0x108> <== NOT EXECUTED
/* for each cluster of the file ... */
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
/* for each sector in cluster ... */
for ( i = 0; i < fs_info->vol.spc; i++ )
ffc1810c: 88 1e 00 04 lbz r0,4(r30) <== NOT EXECUTED
ffc18110: 7f 80 f8 40 cmplw cr7,r0,r31 <== NOT EXECUTED
ffc18114: 40 9d 00 70 ble- cr7,ffc18184 <fat_file_datasync+0x154> <== NOT EXECUTED
{
/* ... sync it */
sc = rtems_bdbuf_read(fs_info->vol.dev, (sec + i), &block);
ffc18118: 80 7e 00 58 lwz r3,88(r30) <== NOT EXECUTED
ffc1811c: 7c bf ea 14 add r5,r31,r29 <== NOT EXECUTED
ffc18120: 80 9e 00 5c lwz r4,92(r30) <== NOT EXECUTED
ffc18124: 38 c1 00 08 addi r6,r1,8 <== NOT EXECUTED
/* for each cluster of the file ... */
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
/* for each sector in cluster ... */
for ( i = 0; i < fs_info->vol.spc; i++ )
ffc18128: 3b ff 00 01 addi r31,r31,1 <== NOT EXECUTED
{
/* ... sync it */
sc = rtems_bdbuf_read(fs_info->vol.dev, (sec + i), &block);
ffc1812c: 4b ff df 81 bl ffc160ac <rtems_bdbuf_read> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc18130: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc18134: 41 9e ff c8 beq+ cr7,ffc180fc <fat_file_datasync+0xcc> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
sc = rtems_bdbuf_sync(block);
if ( sc != RTEMS_SUCCESSFUL )
rtems_set_errno_and_return_minus_one( EIO );
ffc18138: 48 00 c0 d9 bl ffc24210 <__errno> <== NOT EXECUTED
ffc1813c: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc18140: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc18144: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
if ( rc != RC_OK )
return rc;
}
return rc;
}
ffc18148: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc1814c: 80 01 00 34 lwz r0,52(r1) <== NOT EXECUTED
ffc18150: 83 61 00 1c lwz r27,28(r1) <== NOT EXECUTED
ffc18154: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc18158: 83 81 00 20 lwz r28,32(r1) <== NOT EXECUTED
ffc1815c: 83 a1 00 24 lwz r29,36(r1) <== NOT EXECUTED
ffc18160: 83 c1 00 28 lwz r30,40(r1) <== NOT EXECUTED
ffc18164: 83 e1 00 2c lwz r31,44(r1) <== NOT EXECUTED
ffc18168: 38 21 00 30 addi r1,r1,48 <== NOT EXECUTED
ffc1816c: 4e 80 00 20 blr <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
ffc18170: 88 09 00 0a lbz r0,10(r9) <== NOT EXECUTED
ffc18174: 70 0b 00 03 andi. r11,r0,3 <== NOT EXECUTED
ffc18178: 41 a2 ff 5c beq- ffc180d4 <fat_file_datasync+0xa4> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
ffc1817c: 83 a9 00 1c lwz r29,28(r9) <== NOT EXECUTED
ffc18180: 4b ff ff 68 b ffc180e8 <fat_file_datasync+0xb8> <== NOT EXECUTED
/* for each cluster of the file ... */
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
/* for each sector in cluster ... */
for ( i = 0; i < fs_info->vol.spc; i++ )
ffc18184: 80 81 00 0c lwz r4,12(r1) <== NOT EXECUTED
sc = rtems_bdbuf_sync(block);
if ( sc != RTEMS_SUCCESSFUL )
rtems_set_errno_and_return_minus_one( EIO );
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
ffc18188: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc1818c: 38 a1 00 0c addi r5,r1,12 <== NOT EXECUTED
ffc18190: 48 00 9a a5 bl ffc21c34 <fat_get_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
ffc18194: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc18198: 41 82 ff 18 beq+ ffc180b0 <fat_file_datasync+0x80> <== NOT EXECUTED
sc = rtems_bdbuf_sync(block);
if ( sc != RTEMS_SUCCESSFUL )
rtems_set_errno_and_return_minus_one( EIO );
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
ffc1819c: 7c 7c 1b 78 mr r28,r3 <== NOT EXECUTED
ffc181a0: 4b ff fe d8 b ffc18078 <fat_file_datasync+0x48> <== NOT EXECUTED
ffc17a80 <fat_file_extend>:
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t new_length,
uint32_t *a_length
)
{
ffc17a80: 94 21 ff c0 stwu r1,-64(r1)
ffc17a84: 7c 08 02 a6 mflr r0
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t chain = 0;
ffc17a88: 39 20 00 00 li r9,0
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t new_length,
uint32_t *a_length
)
{
ffc17a8c: 90 01 00 44 stw r0,68(r1)
ffc17a90: 93 41 00 28 stw r26,40(r1)
ffc17a94: 7c da 33 78 mr r26,r6
ffc17a98: 93 61 00 2c stw r27,44(r1)
ffc17a9c: 93 81 00 30 stw r28,48(r1)
ffc17aa0: 7c 7c 1b 78 mr r28,r3
ffc17aa4: 93 a1 00 34 stw r29,52(r1)
uint32_t cls_added;
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
return RC_OK;
ffc17aa8: 3b a0 00 00 li r29,0
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t new_length,
uint32_t *a_length
)
{
ffc17aac: 93 c1 00 38 stw r30,56(r1)
ffc17ab0: 7c 9e 23 78 mr r30,r4
ffc17ab4: 93 e1 00 3c stw r31,60(r1)
ffc17ab8: 7c bf 2b 78 mr r31,r5
ffc17abc: 92 e1 00 1c stw r23,28(r1)
ffc17ac0: 93 01 00 20 stw r24,32(r1)
ffc17ac4: 93 21 00 24 stw r25,36(r1)
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc17ac8: 83 63 00 34 lwz r27,52(r3)
uint32_t old_last_cl;
uint32_t last_cl = 0;
uint32_t bytes_remain = 0;
uint32_t cls_added;
*a_length = new_length;
ffc17acc: 90 ba 00 00 stw r5,0(r26)
if (new_length <= fat_fd->fat_file_size)
ffc17ad0: 80 04 00 18 lwz r0,24(r4)
uint32_t *a_length
)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t chain = 0;
ffc17ad4: 91 21 00 14 stw r9,20(r1)
uint32_t bytes_remain = 0;
uint32_t cls_added;
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
ffc17ad8: 7f 85 00 40 cmplw cr7,r5,r0
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t chain = 0;
uint32_t bytes2add = 0;
uint32_t cls2add = 0;
uint32_t old_last_cl;
uint32_t last_cl = 0;
ffc17adc: 91 21 00 0c stw r9,12(r1)
uint32_t bytes_remain = 0;
uint32_t cls_added;
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
ffc17ae0: 40 9d 00 e4 ble- cr7,ffc17bc4 <fat_file_extend+0x144>
return RC_OK;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
ffc17ae4: 81 24 00 20 lwz r9,32(r4)
ffc17ae8: 2f 89 00 01 cmpwi cr7,r9,1
ffc17aec: 41 9e 01 10 beq- cr7,ffc17bfc <fat_file_extend+0x17c> <== NEVER TAKEN
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
rtems_set_errno_and_return_minus_one( ENOSPC );
bytes_remain = (fs_info->vol.bpc -
ffc17af0: a1 7b 00 06 lhz r11,6(r27)
(fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
(fs_info->vol.bpc - 1);
bytes2add = new_length - fat_fd->fat_file_size;
ffc17af4: 7e e0 f8 50 subf r23,r0,r31
* if in last cluster allocated for the file there is enough room to
* handle extention (hence we don't need to add even one cluster to the
* file ) - return
*/
if (bytes2add == 0)
return RC_OK;
ffc17af8: 3b a0 00 00 li r29,0
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
rtems_set_errno_and_return_minus_one( ENOSPC );
bytes_remain = (fs_info->vol.bpc -
(fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
ffc17afc: 39 2b ff ff addi r9,r11,-1
ffc17b00: 7d 39 00 38 and r25,r9,r0
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
rtems_set_errno_and_return_minus_one( ENOSPC );
bytes_remain = (fs_info->vol.bpc -
ffc17b04: 7f 39 58 50 subf r25,r25,r11
ffc17b08: 7f 39 48 38 and r25,r25,r9
(fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
(fs_info->vol.bpc - 1);
bytes2add = new_length - fat_fd->fat_file_size;
if (bytes2add > bytes_remain)
ffc17b0c: 7f 99 b8 40 cmplw cr7,r25,r23
ffc17b10: 40 9c 00 b4 bge- cr7,ffc17bc4 <fat_file_extend+0x144>
/*
* if in last cluster allocated for the file there is enough room to
* handle extention (hence we don't need to add even one cluster to the
* file ) - return
*/
if (bytes2add == 0)
ffc17b14: 7e f9 b8 51 subf. r23,r25,r23
ffc17b18: 41 82 00 ac beq- ffc17bc4 <fat_file_extend+0x144> <== NEVER TAKEN
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
ffc17b1c: 88 1b 00 08 lbz r0,8(r27)
ffc17b20: 3b 17 ff ff addi r24,r23,-1
rc = fat_scan_fat_for_free_clusters(mt_entry, &chain, cls2add,
ffc17b24: 7f 83 e3 78 mr r3,r28
* file ) - return
*/
if (bytes2add == 0)
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
ffc17b28: 7f 18 04 30 srw r24,r24,r0
ffc17b2c: 3b 18 00 01 addi r24,r24,1
rc = fat_scan_fat_for_free_clusters(mt_entry, &chain, cls2add,
ffc17b30: 38 81 00 14 addi r4,r1,20
ffc17b34: 7f 05 c3 78 mr r5,r24
ffc17b38: 38 c1 00 08 addi r6,r1,8
ffc17b3c: 38 e1 00 0c addi r7,r1,12
ffc17b40: 48 00 a8 09 bl ffc22348 <fat_scan_fat_for_free_clusters>
&cls_added, &last_cl);
/* this means that low level I/O error occured */
if (rc != RC_OK)
ffc17b44: 7c 7d 1b 79 mr. r29,r3
ffc17b48: 40 82 00 7c bne- ffc17bc4 <fat_file_extend+0x144> <== NEVER TAKEN
return rc;
/* this means that no space left on device */
if ((cls_added == 0) && (bytes_remain == 0))
ffc17b4c: 80 01 00 08 lwz r0,8(r1)
ffc17b50: 7f 29 03 79 or. r9,r25,r0
ffc17b54: 41 82 00 c0 beq- ffc17c14 <fat_file_extend+0x194> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one(ENOSPC);
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
ffc17b58: 7f 98 00 00 cmpw cr7,r24,r0
ffc17b5c: 41 9e 00 2c beq- cr7,ffc17b88 <fat_file_extend+0x108> <== ALWAYS TAKEN
*a_length = new_length -
((cls2add - cls_added - 1) << fs_info->vol.bpc_log2) -
ffc17b60: 89 7b 00 08 lbz r11,8(r27) <== NOT EXECUTED
ffc17b64: 7c 0a 00 f8 not r10,r0 <== NOT EXECUTED
(bytes2add & (fs_info->vol.bpc - 1));
ffc17b68: a1 3b 00 06 lhz r9,6(r27) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOSPC);
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
*a_length = new_length -
((cls2add - cls_added - 1) << fs_info->vol.bpc_log2) -
ffc17b6c: 7f 0a c2 14 add r24,r10,r24 <== NOT EXECUTED
ffc17b70: 7f 18 58 30 slw r24,r24,r11 <== NOT EXECUTED
(bytes2add & (fs_info->vol.bpc - 1));
ffc17b74: 39 29 ff ff addi r9,r9,-1 <== NOT EXECUTED
if ((cls_added == 0) && (bytes_remain == 0))
rtems_set_errno_and_return_minus_one(ENOSPC);
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
*a_length = new_length -
ffc17b78: 7f 18 f8 50 subf r24,r24,r31 <== NOT EXECUTED
((cls2add - cls_added - 1) << fs_info->vol.bpc_log2) -
(bytes2add & (fs_info->vol.bpc - 1));
ffc17b7c: 7e f7 48 38 and r23,r23,r9 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOSPC);
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
*a_length = new_length -
((cls2add - cls_added - 1) << fs_info->vol.bpc_log2) -
ffc17b80: 7e f7 c0 50 subf r23,r23,r24 <== NOT EXECUTED
if ((cls_added == 0) && (bytes_remain == 0))
rtems_set_errno_and_return_minus_one(ENOSPC);
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
*a_length = new_length -
ffc17b84: 92 fa 00 00 stw r23,0(r26) <== NOT EXECUTED
((cls2add - cls_added - 1) << fs_info->vol.bpc_log2) -
(bytes2add & (fs_info->vol.bpc - 1));
/* add new chain to the end of existed */
if ( fat_fd->fat_file_size == 0 )
ffc17b88: 80 de 00 18 lwz r6,24(r30)
ffc17b8c: 2f 86 00 00 cmpwi cr7,r6,0
ffc17b90: 40 9e 00 98 bne- cr7,ffc17c28 <fat_file_extend+0x1a8>
{
fat_fd->map.disk_cln = fat_fd->cln = chain;
ffc17b94: 81 21 00 14 lwz r9,20(r1)
fat_fd->map.file_cln = 0;
ffc17b98: 90 de 00 34 stw r6,52(r30)
(bytes2add & (fs_info->vol.bpc - 1));
/* add new chain to the end of existed */
if ( fat_fd->fat_file_size == 0 )
{
fat_fd->map.disk_cln = fat_fd->cln = chain;
ffc17b9c: 91 3e 00 1c stw r9,28(r30)
ffc17ba0: 91 3e 00 38 stw r9,56(r30)
}
fat_buf_release(fs_info);
}
/* update number of the last cluster of the file if it changed */
if (cls_added != 0)
ffc17ba4: 2f 80 00 00 cmpwi cr7,r0,0
ffc17ba8: 41 9e 00 18 beq- cr7,ffc17bc0 <fat_file_extend+0x140> <== NEVER TAKEN
{
fat_fd->map.last_cln = last_cl;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
ffc17bac: 80 1e 00 10 lwz r0,16(r30)
ffc17bb0: 2f 80 00 01 cmpwi cr7,r0,1
}
/* update number of the last cluster of the file if it changed */
if (cls_added != 0)
{
fat_fd->map.last_cln = last_cl;
ffc17bb4: 80 01 00 0c lwz r0,12(r1)
ffc17bb8: 90 1e 00 3c stw r0,60(r30)
if (fat_fd->fat_file_type == FAT_DIRECTORY)
ffc17bbc: 41 9e 00 dc beq- cr7,ffc17c98 <fat_file_extend+0x218>
return rc;
}
}
}
fat_fd->fat_file_size = new_length;
ffc17bc0: 93 fe 00 18 stw r31,24(r30)
return RC_OK;
}
ffc17bc4: 80 01 00 44 lwz r0,68(r1)
ffc17bc8: 7f a3 eb 78 mr r3,r29
ffc17bcc: 82 e1 00 1c lwz r23,28(r1)
ffc17bd0: 7c 08 03 a6 mtlr r0
ffc17bd4: 83 01 00 20 lwz r24,32(r1)
ffc17bd8: 83 21 00 24 lwz r25,36(r1)
ffc17bdc: 83 41 00 28 lwz r26,40(r1)
ffc17be0: 83 61 00 2c lwz r27,44(r1)
ffc17be4: 83 81 00 30 lwz r28,48(r1)
ffc17be8: 83 a1 00 34 lwz r29,52(r1)
ffc17bec: 83 c1 00 38 lwz r30,56(r1)
ffc17bf0: 83 e1 00 3c lwz r31,60(r1)
ffc17bf4: 38 21 00 40 addi r1,r1,64
ffc17bf8: 4e 80 00 20 blr
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
return RC_OK;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
ffc17bfc: 81 24 00 24 lwz r9,36(r4) <== NOT EXECUTED
ffc17c00: 2f 89 00 00 cmpwi cr7,r9,0 <== NOT EXECUTED
ffc17c04: 40 be fe ec bne- cr7,ffc17af0 <fat_file_extend+0x70> <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
ffc17c08: 89 3b 00 0a lbz r9,10(r27) <== NOT EXECUTED
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
return RC_OK;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
ffc17c0c: 71 2b 00 03 andi. r11,r9,3 <== NOT EXECUTED
ffc17c10: 41 82 fe e0 beq+ ffc17af0 <fat_file_extend+0x70> <== NOT EXECUTED
if (rc != RC_OK)
return rc;
/* this means that no space left on device */
if ((cls_added == 0) && (bytes_remain == 0))
rtems_set_errno_and_return_minus_one(ENOSPC);
ffc17c14: 48 00 c5 fd bl ffc24210 <__errno> <== NOT EXECUTED
ffc17c18: 38 00 00 1c li r0,28 <== NOT EXECUTED
ffc17c1c: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc17c20: 3b a0 ff ff li r29,-1 <== NOT EXECUTED
ffc17c24: 4b ff ff a0 b ffc17bc4 <fat_file_extend+0x144> <== NOT EXECUTED
fat_fd->map.disk_cln = fat_fd->cln = chain;
fat_fd->map.file_cln = 0;
}
else
{
if (fat_fd->map.last_cln != FAT_UNDEFINED_VALUE)
ffc17c28: 80 9e 00 3c lwz r4,60(r30)
ffc17c2c: 2f 84 ff ff cmpwi cr7,r4,-1
ffc17c30: 41 9e 00 2c beq- cr7,ffc17c5c <fat_file_extend+0x1dc> <== NEVER TAKEN
{
old_last_cl = fat_fd->map.last_cln;
ffc17c34: 90 81 00 10 stw r4,16(r1)
fat_free_fat_clusters_chain(mt_entry, chain);
return rc;
}
}
rc = fat_set_fat_cluster(mt_entry, old_last_cl, chain);
ffc17c38: 80 a1 00 14 lwz r5,20(r1)
ffc17c3c: 7f 83 e3 78 mr r3,r28
ffc17c40: 48 00 a2 59 bl ffc21e98 <fat_set_fat_cluster>
if ( rc != RC_OK )
ffc17c44: 7c 7a 1b 79 mr. r26,r3
ffc17c48: 40 82 00 3c bne- ffc17c84 <fat_file_extend+0x204> <== NEVER TAKEN
{
fat_free_fat_clusters_chain(mt_entry, chain);
return rc;
}
fat_buf_release(fs_info);
ffc17c4c: 7f 63 db 78 mr r3,r27
ffc17c50: 48 00 08 b1 bl ffc18500 <fat_buf_release>
ffc17c54: 80 01 00 08 lwz r0,8(r1)
ffc17c58: 4b ff ff 4c b ffc17ba4 <fat_file_extend+0x124>
{
old_last_cl = fat_fd->map.last_cln;
}
else
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
ffc17c5c: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc17c60: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc17c64: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc17c68: 38 c6 ff ff addi r6,r6,-1 <== NOT EXECUTED
ffc17c6c: 38 e1 00 10 addi r7,r1,16 <== NOT EXECUTED
ffc17c70: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc17c74: 4b ff fd 09 bl ffc1797c <fat_file_ioctl> <== NOT EXECUTED
(fat_fd->fat_file_size - 1), &old_last_cl);
if ( rc != RC_OK )
{
fat_free_fat_clusters_chain(mt_entry, chain);
return rc;
ffc17c78: 80 81 00 10 lwz r4,16(r1) <== NOT EXECUTED
}
else
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
(fat_fd->fat_file_size - 1), &old_last_cl);
if ( rc != RC_OK )
ffc17c7c: 7c 7a 1b 79 mr. r26,r3 <== NOT EXECUTED
ffc17c80: 41 82 ff b8 beq+ ffc17c38 <fat_file_extend+0x1b8> <== NOT EXECUTED
}
rc = fat_set_fat_cluster(mt_entry, old_last_cl, chain);
if ( rc != RC_OK )
{
fat_free_fat_clusters_chain(mt_entry, chain);
ffc17c84: 80 81 00 14 lwz r4,20(r1) <== NOT EXECUTED
ffc17c88: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
return rc;
ffc17c8c: 7f 5d d3 78 mr r29,r26 <== NOT EXECUTED
}
rc = fat_set_fat_cluster(mt_entry, old_last_cl, chain);
if ( rc != RC_OK )
{
fat_free_fat_clusters_chain(mt_entry, chain);
ffc17c90: 48 00 a5 6d bl ffc221fc <fat_free_fat_clusters_chain> <== NOT EXECUTED
return rc;
ffc17c94: 4b ff ff 30 b ffc17bc4 <fat_file_extend+0x144> <== NOT EXECUTED
if (cls_added != 0)
{
fat_fd->map.last_cln = last_cl;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
{
rc = fat_init_clusters_chain(mt_entry, chain);
ffc17c98: 80 81 00 14 lwz r4,20(r1)
ffc17c9c: 7f 83 e3 78 mr r3,r28
ffc17ca0: 48 00 0c c9 bl ffc18968 <fat_init_clusters_chain>
if ( rc != RC_OK )
ffc17ca4: 7c 7b 1b 79 mr. r27,r3
ffc17ca8: 41 82 ff 18 beq+ ffc17bc0 <fat_file_extend+0x140> <== ALWAYS TAKEN
{
fat_free_fat_clusters_chain(mt_entry, chain);
ffc17cac: 80 81 00 14 lwz r4,20(r1) <== NOT EXECUTED
ffc17cb0: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
return rc;
ffc17cb4: 7f 7d db 78 mr r29,r27 <== NOT EXECUTED
if (fat_fd->fat_file_type == FAT_DIRECTORY)
{
rc = fat_init_clusters_chain(mt_entry, chain);
if ( rc != RC_OK )
{
fat_free_fat_clusters_chain(mt_entry, chain);
ffc17cb8: 48 00 a5 45 bl ffc221fc <fat_free_fat_clusters_chain> <== NOT EXECUTED
return rc;
ffc17cbc: 4b ff ff 08 b ffc17bc4 <fat_file_extend+0x144> <== NOT EXECUTED
ffc1797c <fat_file_ioctl>:
fat_file_ioctl(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
int cmd,
...)
{
ffc1797c: 94 21 ff d0 stwu r1,-48(r1)
ffc17980: 7c 08 02 a6 mflr r0
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
switch (cmd)
ffc17984: 2f 85 00 01 cmpwi cr7,r5,1
fat_file_ioctl(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
int cmd,
...)
{
ffc17988: 90 01 00 34 stw r0,52(r1)
uint32_t cl_start = 0;
uint32_t pos = 0;
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
ffc1798c: 7c 29 0b 78 mr r9,r1
ffc17990: 38 01 00 38 addi r0,r1,56
fat_file_ioctl(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
int cmd,
...)
{
ffc17994: 90 c1 00 1c stw r6,28(r1)
ffc17998: 90 e1 00 20 stw r7,32(r1)
ffc1799c: 93 c1 00 28 stw r30,40(r1)
ffc179a0: 93 e1 00 2c stw r31,44(r1)
uint32_t cl_start = 0;
uint32_t pos = 0;
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
ffc179a4: 94 09 00 10 stwu r0,16(r9)
int cmd,
...)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = 0;
ffc179a8: 38 00 00 00 li r0,0
ffc179ac: 90 01 00 08 stw r0,8(r1)
uint32_t cl_start = 0;
uint32_t pos = 0;
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
ffc179b0: 38 00 00 03 li r0,3
fat_file_fd_t *fat_fd,
int cmd,
...)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc179b4: 81 63 00 34 lwz r11,52(r3)
uint32_t cl_start = 0;
uint32_t pos = 0;
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
ffc179b8: 98 01 00 0c stb r0,12(r1)
ffc179bc: 91 21 00 14 stw r9,20(r1)
switch (cmd)
ffc179c0: 41 9e 00 2c beq- cr7,ffc179ec <fat_file_ioctl+0x70> <== ALWAYS TAKEN
*ret = cur_cln;
break;
default:
errno = EINVAL;
ffc179c4: 48 00 c8 4d bl ffc24210 <__errno> <== NOT EXECUTED
ffc179c8: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc179cc: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
rc = -1;
ffc179d0: 38 60 ff ff li r3,-1 <== NOT EXECUTED
break;
}
va_end(ap);
return rc;
}
ffc179d4: 80 01 00 34 lwz r0,52(r1)
ffc179d8: 83 c1 00 28 lwz r30,40(r1)
ffc179dc: 7c 08 03 a6 mtlr r0
ffc179e0: 83 e1 00 2c lwz r31,44(r1)
ffc179e4: 38 21 00 30 addi r1,r1,48
ffc179e8: 4e 80 00 20 blr
va_start(ap, cmd);
switch (cmd)
{
case F_CLU_NUM:
pos = va_arg(ap, uint32_t);
ffc179ec: 80 09 00 0c lwz r0,12(r9)
ret = va_arg(ap, uint32_t *);
ffc179f0: 3b c0 00 05 li r30,5
/* sanity check */
if ( pos >= fat_fd->fat_file_size ) {
ffc179f4: 81 44 00 18 lwz r10,24(r4)
switch (cmd)
{
case F_CLU_NUM:
pos = va_arg(ap, uint32_t);
ret = va_arg(ap, uint32_t *);
ffc179f8: 9b c1 00 0c stb r30,12(r1)
/* sanity check */
if ( pos >= fat_fd->fat_file_size ) {
ffc179fc: 7f 8a 00 40 cmplw cr7,r10,r0
switch (cmd)
{
case F_CLU_NUM:
pos = va_arg(ap, uint32_t);
ret = va_arg(ap, uint32_t *);
ffc17a00: 83 e9 00 10 lwz r31,16(r9)
/* sanity check */
if ( pos >= fat_fd->fat_file_size ) {
ffc17a04: 40 9d 00 6c ble- cr7,ffc17a70 <fat_file_ioctl+0xf4> <== NEVER TAKEN
va_end(ap);
rtems_set_errno_and_return_minus_one( EIO );
}
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
ffc17a08: 81 24 00 20 lwz r9,32(r4)
ffc17a0c: 2f 89 00 01 cmpwi cr7,r9,1
ffc17a10: 41 9e 00 3c beq- cr7,ffc17a4c <fat_file_ioctl+0xd0>
*ret = 0;
rc = RC_OK;
break;
}
cl_start = pos >> fs_info->vol.bpc_log2;
ffc17a14: 88 ab 00 08 lbz r5,8(r11)
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
ffc17a18: 38 c1 00 08 addi r6,r1,8
ffc17a1c: 7c 05 2c 30 srw r5,r0,r5
ffc17a20: 4b ff f6 29 bl ffc17048 <fat_file_lseek>
if ( rc != RC_OK )
ffc17a24: 7c 83 23 79 mr. r3,r4
ffc17a28: 40 a2 ff ac bne- ffc179d4 <fat_file_ioctl+0x58> <== NEVER TAKEN
break;
*ret = cur_cln;
ffc17a2c: 80 01 00 08 lwz r0,8(r1)
rc = -1;
break;
}
va_end(ap);
return rc;
}
ffc17a30: 83 c1 00 28 lwz r30,40(r1)
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if ( rc != RC_OK )
break;
*ret = cur_cln;
ffc17a34: 90 1f 00 00 stw r0,0(r31)
rc = -1;
break;
}
va_end(ap);
return rc;
}
ffc17a38: 80 01 00 34 lwz r0,52(r1)
ffc17a3c: 83 e1 00 2c lwz r31,44(r1)
ffc17a40: 38 21 00 30 addi r1,r1,48
ffc17a44: 7c 08 03 a6 mtlr r0
ffc17a48: 4e 80 00 20 blr
if ( pos >= fat_fd->fat_file_size ) {
va_end(ap);
rtems_set_errno_and_return_minus_one( EIO );
}
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
ffc17a4c: 81 24 00 24 lwz r9,36(r4)
ffc17a50: 2f 89 00 00 cmpwi cr7,r9,0
ffc17a54: 40 be ff c0 bne- cr7,ffc17a14 <fat_file_ioctl+0x98> <== NEVER TAKEN
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
ffc17a58: 89 4b 00 0a lbz r10,10(r11)
if ( pos >= fat_fd->fat_file_size ) {
va_end(ap);
rtems_set_errno_and_return_minus_one( EIO );
}
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
ffc17a5c: 71 48 00 03 andi. r8,r10,3
ffc17a60: 41 a2 ff b4 beq- ffc17a14 <fat_file_ioctl+0x98> <== NEVER TAKEN
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
/* cluster 0 (zero) reserved for root dir */
*ret = 0;
ffc17a64: 91 3f 00 00 stw r9,0(r31)
rc = RC_OK;
ffc17a68: 38 60 00 00 li r3,0
break;
ffc17a6c: 4b ff ff 68 b ffc179d4 <fat_file_ioctl+0x58>
ret = va_arg(ap, uint32_t *);
/* sanity check */
if ( pos >= fat_fd->fat_file_size ) {
va_end(ap);
rtems_set_errno_and_return_minus_one( EIO );
ffc17a70: 48 00 c7 a1 bl ffc24210 <__errno> <== NOT EXECUTED
ffc17a74: 93 c3 00 00 stw r30,0(r3) <== NOT EXECUTED
ffc17a78: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc17a7c: 4b ff ff 58 b ffc179d4 <fat_file_ioctl+0x58> <== NOT EXECUTED
ffc17048 <fat_file_lseek>:
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t file_cln,
uint32_t *disk_cln
)
{
ffc17048: 94 21 ff d0 stwu r1,-48(r1)
ffc1704c: 7c 08 02 a6 mflr r0
ffc17050: 90 01 00 34 stw r0,52(r1)
ffc17054: 93 61 00 1c stw r27,28(r1)
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
ffc17058: 83 64 00 34 lwz r27,52(r4)
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t file_cln,
uint32_t *disk_cln
)
{
ffc1705c: 93 41 00 18 stw r26,24(r1)
ffc17060: 7c da 33 78 mr r26,r6
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
ffc17064: 7f 9b 28 00 cmpw cr7,r27,r5
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t file_cln,
uint32_t *disk_cln
)
{
ffc17068: 93 a1 00 24 stw r29,36(r1)
ffc1706c: 7c 9d 23 78 mr r29,r4
ffc17070: 93 c1 00 28 stw r30,40(r1)
ffc17074: 7c be 2b 78 mr r30,r5
ffc17078: 93 e1 00 2c stw r31,44(r1)
ffc1707c: 7c 7f 1b 78 mr r31,r3
ffc17080: 93 81 00 20 stw r28,32(r1)
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
ffc17084: 41 9e 00 d8 beq- cr7,ffc1715c <fat_file_lseek+0x114> <== ALWAYS TAKEN
{
uint32_t cur_cln;
uint32_t count;
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
ffc17088: 7f 9b 28 40 cmplw cr7,r27,r5 <== NOT EXECUTED
ffc1708c: 41 9c 00 7c blt- cr7,ffc17108 <fat_file_lseek+0xc0> <== NOT EXECUTED
cur_cln = fat_fd->map.disk_cln;
count = file_cln - fat_fd->map.file_cln;
}
else
{
cur_cln = fat_fd->cln;
ffc17090: 80 84 00 1c lwz r4,28(r4) <== NOT EXECUTED
ffc17094: 7c bb 2b 78 mr r27,r5 <== NOT EXECUTED
ffc17098: 90 81 00 08 stw r4,8(r1) <== NOT EXECUTED
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
ffc1709c: 2f 9b 00 00 cmpwi cr7,r27,0 <== NOT EXECUTED
ffc170a0: 41 9e 00 78 beq- cr7,ffc17118 <fat_file_lseek+0xd0> <== NOT EXECUTED
ffc170a4: 3b 80 00 00 li r28,0 <== NOT EXECUTED
ffc170a8: 48 00 00 0c b ffc170b4 <fat_file_lseek+0x6c> <== NOT EXECUTED
ffc170ac: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
ffc170b0: 41 9e 00 68 beq- cr7,ffc17118 <fat_file_lseek+0xd0> <== NOT EXECUTED
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
ffc170b4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc170b8: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
ffc170bc: 48 00 ab 79 bl ffc21c34 <fat_get_fat_cluster> <== NOT EXECUTED
cur_cln = fat_fd->cln;
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
ffc170c0: 3b 9c 00 01 addi r28,r28,1 <== NOT EXECUTED
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
if ( rc != RC_OK )
ffc170c4: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
cur_cln = fat_fd->cln;
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
ffc170c8: 7f 9c d8 00 cmpw cr7,r28,r27 <== NOT EXECUTED
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
if ( rc != RC_OK )
ffc170cc: 41 82 ff e0 beq+ ffc170ac <fat_file_lseek+0x64> <== NOT EXECUTED
fat_fd->map.disk_cln = cur_cln;
*disk_cln = cur_cln;
}
return RC_OK;
}
ffc170d0: 80 01 00 34 lwz r0,52(r1) <== NOT EXECUTED
/* skip over the clusters */
for (i = 0; i < count; i++)
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
if ( rc != RC_OK )
return rc;
ffc170d4: 7c 6b 1b 78 mr r11,r3 <== NOT EXECUTED
ffc170d8: 7c 6a fe 70 srawi r10,r3,31 <== NOT EXECUTED
fat_fd->map.disk_cln = cur_cln;
*disk_cln = cur_cln;
}
return RC_OK;
}
ffc170dc: 83 41 00 18 lwz r26,24(r1) <== NOT EXECUTED
ffc170e0: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc170e4: 7d 43 53 78 mr r3,r10 <== NOT EXECUTED
ffc170e8: 7d 64 5b 78 mr r4,r11 <== NOT EXECUTED
ffc170ec: 83 61 00 1c lwz r27,28(r1) <== NOT EXECUTED
ffc170f0: 83 81 00 20 lwz r28,32(r1) <== NOT EXECUTED
ffc170f4: 83 a1 00 24 lwz r29,36(r1) <== NOT EXECUTED
ffc170f8: 83 c1 00 28 lwz r30,40(r1) <== NOT EXECUTED
ffc170fc: 83 e1 00 2c lwz r31,44(r1) <== NOT EXECUTED
ffc17100: 38 21 00 30 addi r1,r1,48 <== NOT EXECUTED
ffc17104: 4e 80 00 20 blr <== NOT EXECUTED
uint32_t count;
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
{
cur_cln = fat_fd->map.disk_cln;
ffc17108: 80 84 00 38 lwz r4,56(r4) <== NOT EXECUTED
count = file_cln - fat_fd->map.file_cln;
ffc1710c: 7f 7b 28 50 subf r27,r27,r5 <== NOT EXECUTED
uint32_t count;
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
{
cur_cln = fat_fd->map.disk_cln;
ffc17110: 90 81 00 08 stw r4,8(r1) <== NOT EXECUTED
ffc17114: 4b ff ff 88 b ffc1709c <fat_file_lseek+0x54> <== NOT EXECUTED
fat_fd->map.disk_cln = cur_cln;
*disk_cln = cur_cln;
}
return RC_OK;
}
ffc17118: 80 01 00 34 lwz r0,52(r1) <== NOT EXECUTED
fat_fd->map.file_cln = file_cln;
fat_fd->map.disk_cln = cur_cln;
*disk_cln = cur_cln;
}
return RC_OK;
ffc1711c: 39 40 00 00 li r10,0 <== NOT EXECUTED
ffc17120: 39 60 00 00 li r11,0 <== NOT EXECUTED
if ( rc != RC_OK )
return rc;
}
/* update cache */
fat_fd->map.file_cln = file_cln;
ffc17124: 93 dd 00 34 stw r30,52(r29) <== NOT EXECUTED
fat_fd->map.disk_cln = cur_cln;
*disk_cln = cur_cln;
}
return RC_OK;
}
ffc17128: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc1712c: 7d 43 53 78 mr r3,r10 <== NOT EXECUTED
return rc;
}
/* update cache */
fat_fd->map.file_cln = file_cln;
fat_fd->map.disk_cln = cur_cln;
ffc17130: 90 9d 00 38 stw r4,56(r29) <== NOT EXECUTED
*disk_cln = cur_cln;
}
return RC_OK;
}
ffc17134: 83 61 00 1c lwz r27,28(r1) <== NOT EXECUTED
/* update cache */
fat_fd->map.file_cln = file_cln;
fat_fd->map.disk_cln = cur_cln;
*disk_cln = cur_cln;
ffc17138: 90 9a 00 00 stw r4,0(r26) <== NOT EXECUTED
}
return RC_OK;
}
ffc1713c: 7d 64 5b 78 mr r4,r11 <== NOT EXECUTED
ffc17140: 83 41 00 18 lwz r26,24(r1) <== NOT EXECUTED
ffc17144: 83 81 00 20 lwz r28,32(r1) <== NOT EXECUTED
ffc17148: 83 a1 00 24 lwz r29,36(r1) <== NOT EXECUTED
ffc1714c: 83 c1 00 28 lwz r30,40(r1) <== NOT EXECUTED
ffc17150: 83 e1 00 2c lwz r31,44(r1) <== NOT EXECUTED
ffc17154: 38 21 00 30 addi r1,r1,48 <== NOT EXECUTED
ffc17158: 4e 80 00 20 blr <== NOT EXECUTED
)
{
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
*disk_cln = fat_fd->map.disk_cln;
ffc1715c: 80 04 00 38 lwz r0,56(r4)
fat_fd->map.file_cln = file_cln;
fat_fd->map.disk_cln = cur_cln;
*disk_cln = cur_cln;
}
return RC_OK;
ffc17160: 39 40 00 00 li r10,0
ffc17164: 39 60 00 00 li r11,0
}
ffc17168: 83 41 00 18 lwz r26,24(r1)
)
{
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
*disk_cln = fat_fd->map.disk_cln;
ffc1716c: 90 06 00 00 stw r0,0(r6)
fat_fd->map.disk_cln = cur_cln;
*disk_cln = cur_cln;
}
return RC_OK;
}
ffc17170: 7d 43 53 78 mr r3,r10
ffc17174: 7d 64 5b 78 mr r4,r11
ffc17178: 80 01 00 34 lwz r0,52(r1)
ffc1717c: 83 61 00 1c lwz r27,28(r1)
ffc17180: 7c 08 03 a6 mtlr r0
ffc17184: 83 81 00 20 lwz r28,32(r1)
ffc17188: 83 a1 00 24 lwz r29,36(r1)
ffc1718c: 83 c1 00 28 lwz r30,40(r1)
ffc17190: 83 e1 00 2c lwz r31,44(r1)
ffc17194: 38 21 00 30 addi r1,r1,48
ffc17198: 4e 80 00 20 blr
ffc17f68 <fat_file_mark_removed>:
void
fat_file_mark_removed(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ffc17f68: 94 21 ff e8 stwu r1,-24(r1) <== NOT EXECUTED
ffc17f6c: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
if (cln == 1)
return 1;
ffc17f70: 39 60 00 01 li r11,1 <== NOT EXECUTED
ffc17f74: 90 01 00 1c stw r0,28(r1) <== NOT EXECUTED
ffc17f78: 81 24 00 20 lwz r9,32(r4) <== NOT EXECUTED
ffc17f7c: 93 c1 00 10 stw r30,16(r1) <== NOT EXECUTED
uint32_t cln
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
if (cln == 1)
ffc17f80: 2f 89 00 01 cmpwi cr7,r9,1 <== NOT EXECUTED
ffc17f84: 93 e1 00 14 stw r31,20(r1) <== NOT EXECUTED
ffc17f88: 7c 9f 23 78 mr r31,r4 <== NOT EXECUTED
ffc17f8c: 93 a1 00 0c stw r29,12(r1) <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc17f90: 83 c3 00 34 lwz r30,52(r3) <== NOT EXECUTED
ffc17f94: 41 9e 00 28 beq- cr7,ffc17fbc <fat_file_mark_removed+0x54><== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
ffc17f98: 2f 89 00 00 cmpwi cr7,r9,0 <== NOT EXECUTED
ffc17f9c: 41 9e 00 80 beq- cr7,ffc1801c <fat_file_mark_removed+0xb4><== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
ffc17fa0: 89 7e 00 05 lbz r11,5(r30) <== NOT EXECUTED
ffc17fa4: 39 29 ff fe addi r9,r9,-2 <== NOT EXECUTED
ffc17fa8: 80 1e 00 30 lwz r0,48(r30) <== NOT EXECUTED
ffc17fac: 7d 2b 58 30 slw r11,r9,r11 <== NOT EXECUTED
ffc17fb0: 7d 6b 02 14 add r11,r11,r0 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
if (cln == 1)
return 1;
return (fat_cluster_num_to_sector_num(mt_entry, cln) <<
ffc17fb4: 88 1e 00 03 lbz r0,3(r30) <== NOT EXECUTED
ffc17fb8: 7d 6b 00 30 slw r11,r11,r0 <== NOT EXECUTED
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
ffc17fbc: 80 1f 00 24 lwz r0,36(r31) <== NOT EXECUTED
ffc17fc0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc17fc4: 54 1d ba 7e rlwinm r29,r0,23,9,31 <== NOT EXECUTED
static inline uint32_t
fat_construct_key(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(mt_entry, pos->cln) +
ffc17fc8: 7f ab ea 14 add r29,r11,r29 <== NOT EXECUTED
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
ffc17fcc: 54 00 df 3e rlwinm r0,r0,27,28,31 <== NOT EXECUTED
fat_construct_key(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(mt_entry, pos->cln) +
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
ffc17fd0: 57 bd 20 36 rlwinm r29,r29,4,0,27 <== NOT EXECUTED
static inline uint32_t
fat_construct_key(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(mt_entry, pos->cln) +
ffc17fd4: 7f bd 02 14 add r29,r29,r0 <== NOT EXECUTED
ffc17fd8: 4b ff 68 01 bl ffc0e7d8 <_Chain_Extract> <== NOT EXECUTED
*/
static inline void
_hash_insert(rtems_chain_control *hash, uint32_t key1, uint32_t key2,
fat_file_fd_t *el)
{
rtems_chain_append((hash) + ((key1) % FAT_HASH_MODULE), &(el)->link);
ffc17fdc: 57 a0 07 fe clrlwi r0,r29,31 <== NOT EXECUTED
ffc17fe0: 80 7e 00 6c lwz r3,108(r30) <== NOT EXECUTED
ffc17fe4: 1c 00 00 0c mulli r0,r0,12 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
ffc17fe8: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc17fec: 7c 63 02 14 add r3,r3,r0 <== NOT EXECUTED
ffc17ff0: 4b ff 67 b9 bl ffc0e7a8 <_Chain_Append> <== NOT EXECUTED
_hash_delete(fs_info->vhash, key, fat_fd->ino, fat_fd);
_hash_insert(fs_info->rhash, key, fat_fd->ino, fat_fd);
fat_fd->flags |= FAT_FILE_REMOVED;
ffc17ff4: 88 1f 00 30 lbz r0,48(r31) <== NOT EXECUTED
ffc17ff8: 60 00 00 01 ori r0,r0,1 <== NOT EXECUTED
ffc17ffc: 98 1f 00 30 stb r0,48(r31) <== NOT EXECUTED
}
ffc18000: 80 01 00 1c lwz r0,28(r1) <== NOT EXECUTED
ffc18004: 83 a1 00 0c lwz r29,12(r1) <== NOT EXECUTED
ffc18008: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc1800c: 83 c1 00 10 lwz r30,16(r1) <== NOT EXECUTED
ffc18010: 83 e1 00 14 lwz r31,20(r1) <== NOT EXECUTED
ffc18014: 38 21 00 18 addi r1,r1,24 <== NOT EXECUTED
ffc18018: 4e 80 00 20 blr <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
ffc1801c: 88 1e 00 0a lbz r0,10(r30) <== NOT EXECUTED
ffc18020: 70 0b 00 03 andi. r11,r0,3 <== NOT EXECUTED
ffc18024: 41 a2 ff 7c beq- ffc17fa0 <fat_file_mark_removed+0x38> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
ffc18028: 81 7e 00 1c lwz r11,28(r30) <== NOT EXECUTED
ffc1802c: 4b ff ff 88 b ffc17fb4 <fat_file_mark_removed+0x4c> <== NOT EXECUTED
ffc1719c <fat_file_open>:
fat_file_open(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
fat_file_fd_t **fat_fd
)
{
ffc1719c: 94 21 ff d8 stwu r1,-40(r1)
ffc171a0: 7c 08 02 a6 mflr r0
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
if (cln == 1)
return 1;
ffc171a4: 39 60 00 01 li r11,1
ffc171a8: 90 01 00 2c stw r0,44(r1)
static inline uint32_t
fat_construct_key(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(mt_entry, pos->cln) +
ffc171ac: 81 24 00 00 lwz r9,0(r4)
ffc171b0: 93 21 00 0c stw r25,12(r1)
ffc171b4: 7c 79 1b 78 mr r25,r3
uint32_t cln
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
if (cln == 1)
ffc171b8: 2f 89 00 01 cmpwi cr7,r9,1
ffc171bc: 93 41 00 10 stw r26,16(r1)
ffc171c0: 7c ba 2b 78 mr r26,r5
ffc171c4: 93 81 00 18 stw r28,24(r1)
ffc171c8: 7c 9c 23 78 mr r28,r4
ffc171cc: 93 e1 00 24 stw r31,36(r1)
ffc171d0: 93 01 00 08 stw r24,8(r1)
ffc171d4: 93 61 00 14 stw r27,20(r1)
ffc171d8: 93 a1 00 1c stw r29,28(r1)
ffc171dc: 93 c1 00 20 stw r30,32(r1)
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc171e0: 83 e3 00 34 lwz r31,52(r3)
ffc171e4: 41 9e 00 28 beq- cr7,ffc1720c <fat_file_open+0x70>
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
ffc171e8: 2f 89 00 00 cmpwi cr7,r9,0
ffc171ec: 41 9e 01 a4 beq- cr7,ffc17390 <fat_file_open+0x1f4>
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
ffc171f0: 89 7f 00 05 lbz r11,5(r31)
ffc171f4: 39 29 ff fe addi r9,r9,-2
ffc171f8: 80 1f 00 30 lwz r0,48(r31)
ffc171fc: 7d 2b 58 30 slw r11,r9,r11
ffc17200: 7d 6b 02 14 add r11,r11,r0
fat_fs_info_t *fs_info = mt_entry->fs_info;
if (cln == 1)
return 1;
return (fat_cluster_num_to_sector_num(mt_entry, cln) <<
ffc17204: 88 1f 00 03 lbz r0,3(r31)
ffc17208: 7d 6b 00 30 slw r11,r11,r0
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
ffc1720c: 80 1c 00 04 lwz r0,4(r28)
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
ffc17210: 81 3f 00 68 lwz r9,104(r31)
ffc17214: 54 1e ba 7e rlwinm r30,r0,23,9,31
static inline uint32_t
fat_construct_key(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(mt_entry, pos->cln) +
ffc17218: 7f cb f2 14 add r30,r11,r30
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
ffc1721c: 57 de 20 36 rlwinm r30,r30,4,0,27
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
ffc17220: 54 00 df 3e rlwinm r0,r0,27,28,31
static inline uint32_t
fat_construct_key(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(mt_entry, pos->cln) +
ffc17224: 7f de 02 14 add r30,r30,r0
uint32_t key1,
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
ffc17228: 57 db 07 fe clrlwi r27,r30,31
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
ffc1722c: 1f 7b 00 0c mulli r27,r27,12
ffc17230: 7d 09 da 14 add r8,r9,r27
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc17234: 7d 29 d8 2e lwzx r9,r9,r27
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
ffc17238: 39 08 00 04 addi r8,r8,4
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
ffc1723c: 7f 89 40 00 cmpw cr7,r9,r8
ffc17240: 41 9e 00 64 beq- cr7,ffc172a4 <fat_file_open+0x108>
ffc17244: 81 69 00 20 lwz r11,32(r9)
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
if (cln == 1)
return 1;
ffc17248: 39 40 00 01 li r10,1
uint32_t cln
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
if (cln == 1)
ffc1724c: 2f 8b 00 01 cmpwi cr7,r11,1
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
ffc17250: 2f 0b 00 00 cmpwi cr6,r11,0
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
ffc17254: 39 6b ff fe addi r11,r11,-2
uint32_t cln
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
if (cln == 1)
ffc17258: 41 9e 00 20 beq- cr7,ffc17278 <fat_file_open+0xdc>
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
ffc1725c: 40 9a 00 dc bne- cr6,ffc17338 <fat_file_open+0x19c>
ffc17260: 88 1f 00 0a lbz r0,10(r31)
ffc17264: 70 0a 00 03 andi. r10,r0,3
ffc17268: 41 82 00 d0 beq- ffc17338 <fat_file_open+0x19c> <== NEVER TAKEN
return fs_info->vol.rdir_loc;
ffc1726c: 81 5f 00 1c lwz r10,28(r31)
fat_fs_info_t *fs_info = mt_entry->fs_info;
if (cln == 1)
return 1;
return (fat_cluster_num_to_sector_num(mt_entry, cln) <<
ffc17270: 88 1f 00 03 lbz r0,3(r31)
ffc17274: 7d 4a 00 30 slw r10,r10,r0
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
ffc17278: 80 09 00 24 lwz r0,36(r9)
ffc1727c: 54 0b ba 7e rlwinm r11,r0,23,9,31
static inline uint32_t
fat_construct_key(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(mt_entry, pos->cln) +
ffc17280: 7d 4a 5a 14 add r10,r10,r11
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
ffc17284: 55 4a 20 36 rlwinm r10,r10,4,0,27
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
ffc17288: 54 00 df 3e rlwinm r0,r0,27,28,31
static inline uint32_t
fat_construct_key(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(mt_entry, pos->cln) +
ffc1728c: 7c 0a 02 14 add r0,r10,r0
{
fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
uint32_t ck = fat_construct_key(mt_entry, &ffd->dir_pos.sname);
if ( (key1) == ck)
ffc17290: 7f 9e 00 00 cmpw cr7,r30,r0
ffc17294: 41 9e 00 b8 beq- cr7,ffc1734c <fat_file_open+0x1b0>
{
*ret = (void *)the_node;
return 0;
}
}
the_node = the_node->next;
ffc17298: 81 29 00 00 lwz r9,0(r9)
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
ffc1729c: 7f 89 40 00 cmpw cr7,r9,r8
ffc172a0: 40 9e ff a4 bne+ cr7,ffc17244 <fat_file_open+0xa8>
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
ffc172a4: 81 3f 00 6c lwz r9,108(r31)
fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
uint32_t ck = fat_construct_key(mt_entry, &ffd->dir_pos.sname);
if ( (key1) == ck)
{
if ( ((key2) == 0) || ((key2) == ffd->ino) )
ffc172a8: 2c 9e 00 00 cmpwi cr1,r30,0
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
ffc172ac: 7d 09 da 14 add r8,r9,r27
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc172b0: 7d 29 d8 2e lwzx r9,r9,r27
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
ffc172b4: 39 08 00 04 addi r8,r8,4
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
ffc172b8: 7f 89 40 00 cmpw cr7,r9,r8
ffc172bc: 40 be 00 4c bne+ cr7,ffc17308 <fat_file_open+0x16c> <== NEVER TAKEN
ffc172c0: 48 00 01 a8 b ffc17468 <fat_file_open+0x2cc>
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
ffc172c4: 88 1f 00 0a lbz r0,10(r31) <== NOT EXECUTED
ffc172c8: 70 0a 00 03 andi. r10,r0,3 <== NOT EXECUTED
ffc172cc: 41 82 00 58 beq- ffc17324 <fat_file_open+0x188> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
ffc172d0: 81 5f 00 1c lwz r10,28(r31) <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
if (cln == 1)
return 1;
return (fat_cluster_num_to_sector_num(mt_entry, cln) <<
ffc172d4: 88 1f 00 03 lbz r0,3(r31) <== NOT EXECUTED
ffc172d8: 7d 4a 00 30 slw r10,r10,r0 <== NOT EXECUTED
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
ffc172dc: 80 09 00 24 lwz r0,36(r9) <== NOT EXECUTED
ffc172e0: 54 0b ba 7e rlwinm r11,r0,23,9,31 <== NOT EXECUTED
static inline uint32_t
fat_construct_key(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(mt_entry, pos->cln) +
ffc172e4: 7d 4a 5a 14 add r10,r10,r11 <== NOT EXECUTED
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
ffc172e8: 55 4a 20 36 rlwinm r10,r10,4,0,27 <== NOT EXECUTED
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
ffc172ec: 54 00 df 3e rlwinm r0,r0,27,28,31 <== NOT EXECUTED
static inline uint32_t
fat_construct_key(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(mt_entry, pos->cln) +
ffc172f0: 7c 0a 02 14 add r0,r10,r0 <== NOT EXECUTED
{
fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
uint32_t ck = fat_construct_key(mt_entry, &ffd->dir_pos.sname);
if ( (key1) == ck)
ffc172f4: 7f 9e 00 00 cmpw cr7,r30,r0 <== NOT EXECUTED
ffc172f8: 41 9e 00 ac beq- cr7,ffc173a4 <fat_file_open+0x208> <== NOT EXECUTED
{
*ret = (void *)the_node;
return 0;
}
}
the_node = the_node->next;
ffc172fc: 81 29 00 00 lwz r9,0(r9) <== NOT EXECUTED
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
ffc17300: 7f 89 40 00 cmpw cr7,r9,r8 <== NOT EXECUTED
ffc17304: 41 9e 01 64 beq- cr7,ffc17468 <fat_file_open+0x2cc> <== NOT EXECUTED
ffc17308: 81 69 00 20 lwz r11,32(r9) <== NOT EXECUTED
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
if (cln == 1)
return 1;
ffc1730c: 39 40 00 01 li r10,1 <== NOT EXECUTED
uint32_t cln
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
if (cln == 1)
ffc17310: 2f 8b 00 01 cmpwi cr7,r11,1 <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
ffc17314: 2f 0b 00 00 cmpwi cr6,r11,0 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
ffc17318: 39 6b ff fe addi r11,r11,-2 <== NOT EXECUTED
uint32_t cln
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
if (cln == 1)
ffc1731c: 41 be ff c0 beq- cr7,ffc172dc <fat_file_open+0x140> <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
ffc17320: 41 ba ff a4 beq- cr6,ffc172c4 <fat_file_open+0x128> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
ffc17324: 89 5f 00 05 lbz r10,5(r31) <== NOT EXECUTED
ffc17328: 80 1f 00 30 lwz r0,48(r31) <== NOT EXECUTED
ffc1732c: 7d 6a 50 30 slw r10,r11,r10 <== NOT EXECUTED
ffc17330: 7d 4a 02 14 add r10,r10,r0 <== NOT EXECUTED
ffc17334: 4b ff ff a0 b ffc172d4 <fat_file_open+0x138> <== NOT EXECUTED
ffc17338: 89 5f 00 05 lbz r10,5(r31)
ffc1733c: 80 1f 00 30 lwz r0,48(r31)
ffc17340: 7d 6a 50 30 slw r10,r11,r10
ffc17344: 7d 4a 02 14 add r10,r10,r0
ffc17348: 4b ff ff 28 b ffc17270 <fat_file_open+0xd4>
rc = _hash_search(mt_entry, fs_info->vhash, key, 0, &lfat_fd);
if ( rc == RC_OK )
{
/* return pointer to fat_file_descriptor allocated before */
(*fat_fd) = lfat_fd;
lfat_fd->links_num++;
ffc1734c: 81 69 00 08 lwz r11,8(r9)
return rc;
ffc17350: 38 60 00 00 li r3,0
/* access "valid" hash table */
rc = _hash_search(mt_entry, fs_info->vhash, key, 0, &lfat_fd);
if ( rc == RC_OK )
{
/* return pointer to fat_file_descriptor allocated before */
(*fat_fd) = lfat_fd;
ffc17354: 91 3a 00 00 stw r9,0(r26)
lfat_fd->links_num++;
ffc17358: 38 0b 00 01 addi r0,r11,1
ffc1735c: 90 09 00 08 stw r0,8(r9)
* other fields of fat-file descriptor will be initialized on upper
* level
*/
return RC_OK;
}
ffc17360: 80 01 00 2c lwz r0,44(r1)
ffc17364: 83 01 00 08 lwz r24,8(r1)
ffc17368: 7c 08 03 a6 mtlr r0
ffc1736c: 83 21 00 0c lwz r25,12(r1)
ffc17370: 83 41 00 10 lwz r26,16(r1)
ffc17374: 83 61 00 14 lwz r27,20(r1)
ffc17378: 83 81 00 18 lwz r28,24(r1)
ffc1737c: 83 a1 00 1c lwz r29,28(r1)
ffc17380: 83 c1 00 20 lwz r30,32(r1)
ffc17384: 83 e1 00 24 lwz r31,36(r1)
ffc17388: 38 21 00 28 addi r1,r1,40
ffc1738c: 4e 80 00 20 blr
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
ffc17390: 88 1f 00 0a lbz r0,10(r31)
ffc17394: 70 0a 00 03 andi. r10,r0,3
ffc17398: 41 a2 fe 58 beq- ffc171f0 <fat_file_open+0x54> <== NEVER TAKEN
return fs_info->vol.rdir_loc;
ffc1739c: 81 7f 00 1c lwz r11,28(r31)
ffc173a0: 4b ff fe 64 b ffc17204 <fat_file_open+0x68>
fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
uint32_t ck = fat_construct_key(mt_entry, &ffd->dir_pos.sname);
if ( (key1) == ck)
{
if ( ((key2) == 0) || ((key2) == ffd->ino) )
ffc173a4: 41 86 00 10 beq- cr1,ffc173b4 <fat_file_open+0x218> <== NOT EXECUTED
ffc173a8: 80 09 00 0c lwz r0,12(r9) <== NOT EXECUTED
ffc173ac: 7f 9e 00 00 cmpw cr7,r30,r0 <== NOT EXECUTED
ffc173b0: 40 9e ff 4c bne+ cr7,ffc172fc <fat_file_open+0x160> <== NOT EXECUTED
{
*ret = (void *)the_node;
return 0;
ffc173b4: 3b 00 00 00 li r24,0 <== NOT EXECUTED
}
/* access "removed-but-still-open" hash table */
rc = _hash_search(mt_entry, fs_info->rhash, key, key, &lfat_fd);
lfat_fd = (*fat_fd) = (fat_file_fd_t*)malloc(sizeof(fat_file_fd_t));
ffc173b8: 38 60 00 44 li r3,68
ffc173bc: 4b ff 1a 31 bl ffc08dec <malloc>
if ( lfat_fd == NULL )
ffc173c0: 2f 83 00 00 cmpwi cr7,r3,0
}
/* access "removed-but-still-open" hash table */
rc = _hash_search(mt_entry, fs_info->rhash, key, key, &lfat_fd);
lfat_fd = (*fat_fd) = (fat_file_fd_t*)malloc(sizeof(fat_file_fd_t));
ffc173c4: 90 7a 00 00 stw r3,0(r26)
ffc173c8: 7c 7d 1b 78 mr r29,r3
if ( lfat_fd == NULL )
ffc173cc: 41 9e 00 c0 beq- cr7,ffc1748c <fat_file_open+0x2f0>
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
ffc173d0: 38 80 00 00 li r4,0
ffc173d4: 38 a0 00 44 li r5,68
ffc173d8: 48 00 dd 51 bl ffc25128 <memset>
lfat_fd->flags &= ~FAT_FILE_REMOVED;
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
lfat_fd->dir_pos = *dir_pos;
if ( rc != RC_OK )
ffc173dc: 2f 98 00 00 cmpwi cr7,r24,0
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
lfat_fd->links_num = 1;
lfat_fd->flags &= ~FAT_FILE_REMOVED;
ffc173e0: 89 1d 00 30 lbz r8,48(r29)
if ( lfat_fd == NULL )
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
lfat_fd->links_num = 1;
ffc173e4: 38 e0 00 01 li r7,1
lfat_fd->flags &= ~FAT_FILE_REMOVED;
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
lfat_fd->dir_pos = *dir_pos;
ffc173e8: 81 5c 00 00 lwz r10,0(r28)
ffc173ec: 81 7c 00 04 lwz r11,4(r28)
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
lfat_fd->links_num = 1;
lfat_fd->flags &= ~FAT_FILE_REMOVED;
ffc173f0: 55 08 00 3c rlwinm r8,r8,0,0,30
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
lfat_fd->dir_pos = *dir_pos;
ffc173f4: 81 3c 00 08 lwz r9,8(r28)
ffc173f8: 80 1c 00 0c lwz r0,12(r28)
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
lfat_fd->links_num = 1;
lfat_fd->flags &= ~FAT_FILE_REMOVED;
ffc173fc: 99 1d 00 30 stb r8,48(r29)
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
ffc17400: 39 00 ff ff li r8,-1
if ( lfat_fd == NULL )
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
lfat_fd->links_num = 1;
ffc17404: 90 fd 00 08 stw r7,8(r29)
lfat_fd->flags &= ~FAT_FILE_REMOVED;
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
ffc17408: 91 1d 00 3c stw r8,60(r29)
lfat_fd->dir_pos = *dir_pos;
ffc1740c: 91 5d 00 20 stw r10,32(r29)
ffc17410: 91 7d 00 24 stw r11,36(r29)
ffc17414: 91 3d 00 28 stw r9,40(r29)
ffc17418: 90 1d 00 2c stw r0,44(r29)
if ( rc != RC_OK )
ffc1741c: 41 9e 00 54 beq- cr7,ffc17470 <fat_file_open+0x2d4> <== NEVER TAKEN
lfat_fd->ino = key;
ffc17420: 93 dd 00 0c stw r30,12(r29)
*/
static inline void
_hash_insert(rtems_chain_control *hash, uint32_t key1, uint32_t key2,
fat_file_fd_t *el)
{
rtems_chain_append((hash) + ((key1) % FAT_HASH_MODULE), &(el)->link);
ffc17424: 80 7f 00 68 lwz r3,104(r31)
ffc17428: 7f a4 eb 78 mr r4,r29
ffc1742c: 7c 63 da 14 add r3,r3,r27
ffc17430: 4b ff 73 79 bl ffc0e7a8 <_Chain_Append>
* other fields of fat-file descriptor will be initialized on upper
* level
*/
return RC_OK;
}
ffc17434: 80 01 00 2c lwz r0,44(r1)
/*
* other fields of fat-file descriptor will be initialized on upper
* level
*/
return RC_OK;
ffc17438: 38 60 00 00 li r3,0
}
ffc1743c: 83 01 00 08 lwz r24,8(r1)
ffc17440: 7c 08 03 a6 mtlr r0
ffc17444: 83 21 00 0c lwz r25,12(r1)
ffc17448: 83 41 00 10 lwz r26,16(r1)
ffc1744c: 83 61 00 14 lwz r27,20(r1)
ffc17450: 83 81 00 18 lwz r28,24(r1)
ffc17454: 83 a1 00 1c lwz r29,28(r1)
ffc17458: 83 c1 00 20 lwz r30,32(r1)
ffc1745c: 83 e1 00 24 lwz r31,36(r1)
ffc17460: 38 21 00 28 addi r1,r1,40
ffc17464: 4e 80 00 20 blr
return 0;
}
}
the_node = the_node->next;
}
return -1;
ffc17468: 3b 00 ff ff li r24,-1
ffc1746c: 4b ff ff 4c b ffc173b8 <fat_file_open+0x21c>
if ( rc != RC_OK )
lfat_fd->ino = key;
else
{
lfat_fd->ino = fat_get_unique_ino(mt_entry);
ffc17470: 7f 23 cb 78 mr r3,r25 <== NOT EXECUTED
ffc17474: 48 00 16 21 bl ffc18a94 <fat_get_unique_ino> <== NOT EXECUTED
if ( lfat_fd->ino == 0 )
ffc17478: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
if ( rc != RC_OK )
lfat_fd->ino = key;
else
{
lfat_fd->ino = fat_get_unique_ino(mt_entry);
ffc1747c: 90 7d 00 0c stw r3,12(r29) <== NOT EXECUTED
if ( lfat_fd->ino == 0 )
ffc17480: 40 9e ff a4 bne+ cr7,ffc17424 <fat_file_open+0x288> <== NOT EXECUTED
{
free((*fat_fd));
ffc17484: 80 7a 00 00 lwz r3,0(r26) <== NOT EXECUTED
ffc17488: 4b ff 10 59 bl ffc084e0 <free> <== NOT EXECUTED
/*
* XXX: kernel resource is unsufficient, but not the memory,
* but there is no suitable errno :(
*/
rtems_set_errno_and_return_minus_one( ENOMEM );
ffc1748c: 48 00 cd 85 bl ffc24210 <__errno>
ffc17490: 38 00 00 0c li r0,12
ffc17494: 90 03 00 00 stw r0,0(r3)
ffc17498: 38 60 ff ff li r3,-1
ffc1749c: 4b ff fe c4 b ffc17360 <fat_file_open+0x1c4>
ffc174b8 <fat_file_read>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
ffc174b8: 94 21 ff c0 stwu r1,-64(r1)
ffc174bc: 7c 08 02 a6 mflr r0
ffc174c0: 93 e1 00 3c stw r31,60(r1)
uint32_t sec = 0;
uint32_t byte = 0;
uint32_t c = 0;
/* it couldn't be removed - otherwise cache update will be broken */
if (count == 0)
ffc174c4: 7c df 33 79 mr. r31,r6
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
ffc174c8: 90 01 00 44 stw r0,68(r1)
int rc = RC_OK;
ssize_t ret = 0;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
ffc174cc: 38 00 00 00 li r0,0
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
ffc174d0: 93 21 00 24 stw r25,36(r1)
ffc174d4: 7c f9 3b 78 mr r25,r7
ffc174d8: 93 41 00 28 stw r26,40(r1)
ffc174dc: 7c 9a 23 78 mr r26,r4
ffc174e0: 93 81 00 30 stw r28,48(r1)
ffc174e4: 93 a1 00 34 stw r29,52(r1)
ffc174e8: 7c 7d 1b 78 mr r29,r3
ffc174ec: 93 c1 00 38 stw r30,56(r1)
ffc174f0: 7c be 2b 78 mr r30,r5
int rc = RC_OK;
ssize_t ret = 0;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc174f4: 83 83 00 34 lwz r28,52(r3)
uint32_t byte = 0;
uint32_t c = 0;
/* it couldn't be removed - otherwise cache update will be broken */
if (count == 0)
return cmpltd;
ffc174f8: 38 60 00 00 li r3,0
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
ffc174fc: 92 c1 00 18 stw r22,24(r1)
ffc17500: 92 e1 00 1c stw r23,28(r1)
ffc17504: 93 01 00 20 stw r24,32(r1)
ffc17508: 93 61 00 2c stw r27,44(r1)
int rc = RC_OK;
ssize_t ret = 0;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
ffc1750c: 90 01 00 08 stw r0,8(r1)
uint32_t sec = 0;
uint32_t byte = 0;
uint32_t c = 0;
/* it couldn't be removed - otherwise cache update will be broken */
if (count == 0)
ffc17510: 41 82 01 48 beq- ffc17658 <fat_file_read+0x1a0> <== NEVER TAKEN
/*
* >= because start is offset and computed from 0 and file_size
* computed from 1
*/
if ( start >= fat_fd->fat_file_size )
ffc17514: 81 24 00 18 lwz r9,24(r4)
ffc17518: 7f 89 28 40 cmplw cr7,r9,r5
ffc1751c: 40 9d 01 3c ble- cr7,ffc17658 <fat_file_read+0x1a0> <== NEVER TAKEN
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
ffc17520: 7f 9f 48 40 cmplw cr7,r31,r9
ffc17524: 40 9d 01 6c ble- cr7,ffc17690 <fat_file_read+0x1d8> <== ALWAYS TAKEN
(start > fat_fd->fat_file_size - count))
count = fat_fd->fat_file_size - start;
ffc17528: 7f fe 48 50 subf r31,r30,r9 <== NOT EXECUTED
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
ffc1752c: 80 1a 00 20 lwz r0,32(r26)
ffc17530: 2f 80 00 01 cmpwi cr7,r0,1
ffc17534: 41 9e 01 6c beq- cr7,ffc176a0 <fat_file_read+0x1e8>
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
ffc17538: 8b 1c 00 08 lbz r24,8(r28)
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
ffc1753c: 7f a3 eb 78 mr r3,r29
ffc17540: 7f 44 d3 78 mr r4,r26
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
ffc17544: a2 fc 00 06 lhz r23,6(r28)
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
ffc17548: 7f d8 c4 30 srw r24,r30,r24
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
ffc1754c: 7f 05 c3 78 mr r5,r24
ffc17550: 38 c1 00 08 addi r6,r1,8
ffc17554: 4b ff fa f5 bl ffc17048 <fat_file_lseek>
if (rc != RC_OK)
ffc17558: 7c 83 23 79 mr. r3,r4
ffc1755c: 40 82 00 fc bne- ffc17658 <fat_file_read+0x1a0> <== NEVER TAKEN
return rc;
while (count > 0)
ffc17560: 2f 9f 00 00 cmpwi cr7,r31,0
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
ffc17564: 3a f7 ff ff addi r23,r23,-1
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
ffc17568: 3a c0 00 00 li r22,0
ffc1756c: 3b 60 00 00 li r27,0
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
ffc17570: 7f d7 b8 38 and r23,r30,r23
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
ffc17574: 41 9e 00 c8 beq- cr7,ffc1763c <fat_file_read+0x184> <== NEVER TAKEN
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
ffc17578: 88 1c 00 02 lbz r0,2(r28)
return rc;
while (count > 0)
ffc1757c: 7e e9 bb 78 mr r9,r23
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
ffc17580: a0 bc 00 00 lhz r5,0(r28)
return rc;
while (count > 0)
ffc17584: 3b 60 00 00 li r27,0
ffc17588: 48 00 00 74 b ffc175fc <fat_file_read+0x144>
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
ffc1758c: 89 4b 00 0a lbz r10,10(r11) <== NOT EXECUTED
ffc17590: 71 48 00 03 andi. r8,r10,3 <== NOT EXECUTED
ffc17594: 41 82 00 90 beq- ffc17624 <fat_file_read+0x16c> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
ffc17598: 80 8b 00 1c lwz r4,28(r11) <== NOT EXECUTED
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
ffc1759c: 7d 20 04 30 srw r0,r9,r0
byte = ofs & (fs_info->vol.bps - 1);
ffc175a0: 38 a5 ff ff addi r5,r5,-1
ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);
ffc175a4: 7c a5 48 38 and r5,r5,r9
ffc175a8: 7c f9 da 14 add r7,r25,r27
ffc175ac: 7c 84 02 14 add r4,r4,r0
ffc175b0: 7f c6 f3 78 mr r6,r30
ffc175b4: 7f a3 eb 78 mr r3,r29
ffc175b8: 48 00 10 ed bl ffc186a4 <_fat_block_read>
if ( ret < 0 )
return -1;
count -= c;
cmpltd += c;
ffc175bc: 7f 7b f2 14 add r27,r27,r30
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
ffc175c0: 2f 83 00 00 cmpwi cr7,r3,0
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
ffc175c4: 38 a1 00 08 addi r5,r1,8
ffc175c8: 7f a3 eb 78 mr r3,r29
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
ffc175cc: 41 9c 01 2c blt- cr7,ffc176f8 <fat_file_read+0x240> <== NEVER TAKEN
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
ffc175d0: 82 c1 00 08 lwz r22,8(r1)
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
ffc175d4: 7f fe f8 50 subf r31,r30,r31
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
ffc175d8: 7e c4 b3 78 mr r4,r22
ffc175dc: 48 00 a6 59 bl ffc21c34 <fat_get_fat_cluster>
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
ffc175e0: 2f 9f 00 00 cmpwi cr7,r31,0
count -= c;
cmpltd += c;
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
if ( rc != RC_OK )
ffc175e4: 2c 03 00 00 cmpwi r3,0
return rc;
ofs = 0;
ffc175e8: 39 20 00 00 li r9,0
count -= c;
cmpltd += c;
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
if ( rc != RC_OK )
ffc175ec: 40 82 00 6c bne- ffc17658 <fat_file_read+0x1a0> <== NEVER TAKEN
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
ffc175f0: 41 9e 00 48 beq- cr7,ffc17638 <fat_file_read+0x180> <== ALWAYS TAKEN
ffc175f4: 88 1c 00 02 lbz r0,2(r28) <== NOT EXECUTED
ffc175f8: a0 bc 00 00 lhz r5,0(r28) <== NOT EXECUTED
{
c = MIN(count, (fs_info->vol.bpc - ofs));
ffc175fc: a3 dc 00 06 lhz r30,6(r28)
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
ffc17600: 80 81 00 08 lwz r4,8(r1)
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
ffc17604: 7f c9 f0 50 subf r30,r9,r30
ffc17608: 7f 1e f8 40 cmplw cr6,r30,r31
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
ffc1760c: 2f 84 00 00 cmpwi cr7,r4,0
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
ffc17610: 38 84 ff fe addi r4,r4,-2
ffc17614: 40 99 00 08 ble- cr6,ffc1761c <fat_file_read+0x164>
ffc17618: 7f fe fb 78 mr r30,r31
fat_fd->map.disk_cln = cur_cln;
*disk_cln = cur_cln;
}
return RC_OK;
}
ffc1761c: 81 7d 00 34 lwz r11,52(r29)
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
ffc17620: 41 be ff 6c beq- cr7,ffc1758c <fat_file_read+0xd4> <== NEVER TAKEN
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
ffc17624: 89 4b 00 05 lbz r10,5(r11)
ffc17628: 81 6b 00 30 lwz r11,48(r11)
ffc1762c: 7c 84 50 30 slw r4,r4,r10
ffc17630: 7c 84 5a 14 add r4,r4,r11
ffc17634: 4b ff ff 68 b ffc1759c <fat_file_read+0xe4>
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
if ( rc != RC_OK )
return rc;
ofs = 0;
ffc17638: 7f 63 db 78 mr r3,r27
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
ffc1763c: 88 1c 00 08 lbz r0,8(r28)
ffc17640: 3a f7 ff ff addi r23,r23,-1
ffc17644: 7f 77 da 14 add r27,r23,r27
fat_fd->map.disk_cln = save_cln;
ffc17648: 92 da 00 38 stw r22,56(r26)
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
ffc1764c: 7f 7b 04 30 srw r27,r27,r0
ofs = 0;
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
ffc17650: 7f 1b c2 14 add r24,r27,r24
ffc17654: 93 1a 00 34 stw r24,52(r26)
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
}
ffc17658: 80 01 00 44 lwz r0,68(r1)
ffc1765c: 82 c1 00 18 lwz r22,24(r1)
ffc17660: 7c 08 03 a6 mtlr r0
ffc17664: 82 e1 00 1c lwz r23,28(r1)
ffc17668: 83 01 00 20 lwz r24,32(r1)
ffc1766c: 83 21 00 24 lwz r25,36(r1)
ffc17670: 83 41 00 28 lwz r26,40(r1)
ffc17674: 83 61 00 2c lwz r27,44(r1)
ffc17678: 83 81 00 30 lwz r28,48(r1)
ffc1767c: 83 a1 00 34 lwz r29,52(r1)
ffc17680: 83 c1 00 38 lwz r30,56(r1)
ffc17684: 83 e1 00 3c lwz r31,60(r1)
ffc17688: 38 21 00 40 addi r1,r1,64
ffc1768c: 4e 80 00 20 blr
*/
if ( start >= fat_fd->fat_file_size )
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
(start > fat_fd->fat_file_size - count))
ffc17690: 7c 1f 48 50 subf r0,r31,r9
* computed from 1
*/
if ( start >= fat_fd->fat_file_size )
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
ffc17694: 7f 85 00 40 cmplw cr7,r5,r0
ffc17698: 40 bd fe 94 ble- cr7,ffc1752c <fat_file_read+0x74> <== ALWAYS TAKEN
ffc1769c: 4b ff fe 8c b ffc17528 <fat_file_read+0x70> <== NOT EXECUTED
(start > fat_fd->fat_file_size - count))
count = fat_fd->fat_file_size - start;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
ffc176a0: 80 1a 00 24 lwz r0,36(r26)
ffc176a4: 2f 80 00 00 cmpwi cr7,r0,0
ffc176a8: 40 be fe 90 bne- cr7,ffc17538 <fat_file_read+0x80> <== NEVER TAKEN
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
ffc176ac: 88 1c 00 0a lbz r0,10(r28)
if ((count > fat_fd->fat_file_size) ||
(start > fat_fd->fat_file_size - count))
count = fat_fd->fat_file_size - start;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
ffc176b0: 70 08 00 03 andi. r8,r0,3
ffc176b4: 41 a2 fe 84 beq- ffc17538 <fat_file_read+0x80> <== NEVER TAKEN
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
ffc176b8: 81 3a 00 1c lwz r9,28(r26)
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
ffc176bc: 2f 89 00 00 cmpwi cr7,r9,0
ffc176c0: 40 9e 00 40 bne- cr7,ffc17700 <fat_file_read+0x248> <== NEVER TAKEN
return fs_info->vol.rdir_loc;
ffc176c4: 80 9c 00 1c lwz r4,28(r28)
sec += (start >> fs_info->vol.sec_log2);
ffc176c8: 88 1c 00 02 lbz r0,2(r28)
byte = start & (fs_info->vol.bps - 1);
ret = _fat_block_read(mt_entry, sec, byte, count, buf);
ffc176cc: 7f a3 eb 78 mr r3,r29
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
byte = start & (fs_info->vol.bps - 1);
ffc176d0: a0 bc 00 00 lhz r5,0(r28)
ret = _fat_block_read(mt_entry, sec, byte, count, buf);
ffc176d4: 7f e6 fb 78 mr r6,r31
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
ffc176d8: 7f c0 04 30 srw r0,r30,r0
byte = start & (fs_info->vol.bps - 1);
ffc176dc: 38 a5 ff ff addi r5,r5,-1
ret = _fat_block_read(mt_entry, sec, byte, count, buf);
ffc176e0: 7c 84 02 14 add r4,r4,r0
ffc176e4: 7f c5 28 38 and r5,r30,r5
ffc176e8: 7f 27 cb 78 mr r7,r25
ffc176ec: 48 00 0f b9 bl ffc186a4 <_fat_block_read>
if ( ret < 0 )
ffc176f0: 2c 03 00 00 cmpwi r3,0
ffc176f4: 40 80 ff 64 bge+ ffc17658 <fat_file_read+0x1a0> <== ALWAYS TAKEN
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
ffc176f8: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc176fc: 4b ff ff 5c b ffc17658 <fat_file_read+0x1a0> <== NOT EXECUTED
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
ffc17700: 89 7c 00 05 lbz r11,5(r28) <== NOT EXECUTED
ffc17704: 38 89 ff fe addi r4,r9,-2 <== NOT EXECUTED
ffc17708: 80 1c 00 30 lwz r0,48(r28) <== NOT EXECUTED
ffc1770c: 7c 84 58 30 slw r4,r4,r11 <== NOT EXECUTED
ffc17710: 7c 84 02 14 add r4,r4,r0 <== NOT EXECUTED
ffc17714: 4b ff ff b4 b ffc176c8 <fat_file_read+0x210> <== NOT EXECUTED
ffc181a4 <fat_file_size>:
int
fat_file_size(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ffc181a4: 94 21 ff d8 stwu r1,-40(r1)
ffc181a8: 7c 08 02 a6 mflr r0
ffc181ac: 90 01 00 2c stw r0,44(r1)
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
uint32_t save_cln = 0;
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
ffc181b0: 80 04 00 20 lwz r0,32(r4)
int
fat_file_size(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ffc181b4: 93 a1 00 1c stw r29,28(r1)
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
uint32_t save_cln = 0;
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
ffc181b8: 2f 80 00 01 cmpwi cr7,r0,1
fat_file_fd_t *fat_fd
)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
ffc181bc: 83 a4 00 1c lwz r29,28(r4)
int
fat_file_size(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ffc181c0: 93 81 00 18 stw r28,24(r1)
ffc181c4: 7c 7c 1b 78 mr r28,r3
ffc181c8: 93 c1 00 20 stw r30,32(r1)
ffc181cc: 7c 9e 23 78 mr r30,r4
ffc181d0: 93 e1 00 24 stw r31,36(r1)
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
ffc181d4: 93 a1 00 08 stw r29,8(r1)
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc181d8: 83 e3 00 34 lwz r31,52(r3)
uint32_t cur_cln = fat_fd->cln;
uint32_t save_cln = 0;
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
ffc181dc: 41 9e 00 b4 beq- cr7,ffc18290 <fat_file_size+0xec> <== NEVER TAKEN
return rc;
}
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
ffc181e0: 81 3f 00 0c lwz r9,12(r31)
ffc181e4: 80 1f 00 10 lwz r0,16(r31)
ffc181e8: 7f a9 48 38 and r9,r29,r9
ffc181ec: 7f 89 00 40 cmplw cr7,r9,r0
{
fat_fd->fat_file_size = fs_info->vol.rdir_size;
return rc;
}
fat_fd->fat_file_size = 0;
ffc181f0: 38 00 00 00 li r0,0
ffc181f4: 90 1e 00 18 stw r0,24(r30)
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
ffc181f8: 41 bc 00 34 blt+ cr7,ffc1822c <fat_file_size+0x88> <== ALWAYS TAKEN
ffc181fc: 48 00 00 68 b ffc18264 <fat_file_size+0xc0> <== NOT EXECUTED
ffc18200: 81 7f 00 0c lwz r11,12(r31)
ffc18204: 80 01 00 08 lwz r0,8(r1)
ffc18208: 81 3f 00 10 lwz r9,16(r31)
ffc1820c: 7c 0b 58 38 and r11,r0,r11
ffc18210: 7f 8b 48 40 cmplw cr7,r11,r9
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
if ( rc != RC_OK )
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
ffc18214: a1 3f 00 06 lhz r9,6(r31)
ffc18218: 81 7e 00 18 lwz r11,24(r30)
ffc1821c: 7d 2b 4a 14 add r9,r11,r9
ffc18220: 91 3e 00 18 stw r9,24(r30)
return rc;
}
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
ffc18224: 40 9c 00 44 bge- cr7,ffc18268 <fat_file_size+0xc4> <== ALWAYS TAKEN
ffc18228: 7c 1d 03 78 mr r29,r0 <== NOT EXECUTED
{
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
ffc1822c: 7f a4 eb 78 mr r4,r29
ffc18230: 7f 83 e3 78 mr r3,r28
ffc18234: 38 a1 00 08 addi r5,r1,8
ffc18238: 48 00 99 fd bl ffc21c34 <fat_get_fat_cluster>
if ( rc != RC_OK )
ffc1823c: 2c 03 00 00 cmpwi r3,0
ffc18240: 41 82 ff c0 beq+ ffc18200 <fat_file_size+0x5c> <== ALWAYS TAKEN
fat_fd->fat_file_size += fs_info->vol.bpc;
}
fat_fd->map.last_cln = save_cln;
return rc;
}
ffc18244: 80 01 00 2c lwz r0,44(r1) <== NOT EXECUTED
ffc18248: 83 81 00 18 lwz r28,24(r1) <== NOT EXECUTED
ffc1824c: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc18250: 83 a1 00 1c lwz r29,28(r1) <== NOT EXECUTED
ffc18254: 83 c1 00 20 lwz r30,32(r1) <== NOT EXECUTED
ffc18258: 83 e1 00 24 lwz r31,36(r1) <== NOT EXECUTED
ffc1825c: 38 21 00 28 addi r1,r1,40 <== NOT EXECUTED
ffc18260: 4e 80 00 20 blr <== NOT EXECUTED
)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
uint32_t save_cln = 0;
ffc18264: 3b a0 00 00 li r29,0 <== NOT EXECUTED
fat_fd->fat_file_size += fs_info->vol.bpc;
}
fat_fd->map.last_cln = save_cln;
return rc;
}
ffc18268: 80 01 00 2c lwz r0,44(r1)
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
}
fat_fd->map.last_cln = save_cln;
return rc;
ffc1826c: 38 60 00 00 li r3,0
if ( rc != RC_OK )
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
}
fat_fd->map.last_cln = save_cln;
ffc18270: 93 be 00 3c stw r29,60(r30)
return rc;
}
ffc18274: 7c 08 03 a6 mtlr r0
ffc18278: 83 81 00 18 lwz r28,24(r1)
ffc1827c: 83 a1 00 1c lwz r29,28(r1)
ffc18280: 83 c1 00 20 lwz r30,32(r1)
ffc18284: 83 e1 00 24 lwz r31,36(r1)
ffc18288: 38 21 00 28 addi r1,r1,40
ffc1828c: 4e 80 00 20 blr
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
uint32_t save_cln = 0;
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
ffc18290: 80 04 00 24 lwz r0,36(r4) <== NOT EXECUTED
ffc18294: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc18298: 40 be ff 48 bne- cr7,ffc181e0 <fat_file_size+0x3c> <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
ffc1829c: 88 1f 00 0a lbz r0,10(r31) <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
uint32_t save_cln = 0;
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
ffc182a0: 70 09 00 03 andi. r9,r0,3 <== NOT EXECUTED
ffc182a4: 41 82 ff 3c beq+ ffc181e0 <fat_file_size+0x3c> <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
fat_fd->fat_file_size = fs_info->vol.rdir_size;
ffc182a8: 80 1f 00 28 lwz r0,40(r31) <== NOT EXECUTED
return rc;
ffc182ac: 38 60 00 00 li r3,0 <== NOT EXECUTED
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
fat_fd->fat_file_size = fs_info->vol.rdir_size;
ffc182b0: 90 04 00 18 stw r0,24(r4) <== NOT EXECUTED
return rc;
ffc182b4: 4b ff ff 90 b ffc18244 <fat_file_size+0xa0> <== NOT EXECUTED
ffc17718 <fat_file_truncate>:
fat_file_truncate(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t new_length
)
{
ffc17718: 94 21 ff d8 stwu r1,-40(r1)
ffc1771c: 7c 08 02 a6 mflr r0
ffc17720: 7d 80 00 26 mfcr r12
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = 0;
ffc17724: 39 60 00 00 li r11,0
fat_file_truncate(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t new_length
)
{
ffc17728: 90 01 00 2c stw r0,44(r1)
uint32_t cur_cln = 0;
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
if ( new_length >= fat_fd->fat_file_size )
ffc1772c: 80 04 00 18 lwz r0,24(r4)
uint32_t new_length
)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = 0;
ffc17730: 91 61 00 0c stw r11,12(r1)
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
ffc17734: 39 60 ff ff li r11,-1
if ( new_length >= fat_fd->fat_file_size )
ffc17738: 7f 80 28 40 cmplw cr7,r0,r5
fat_file_truncate(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t new_length
)
{
ffc1773c: 93 c1 00 20 stw r30,32(r1)
ffc17740: 7c 9e 23 78 mr r30,r4
ffc17744: 93 e1 00 24 stw r31,36(r1)
ffc17748: 7c 7f 1b 78 mr r31,r3
ffc1774c: 93 a1 00 1c stw r29,28(r1)
ffc17750: 91 81 00 18 stw r12,24(r1)
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc17754: 81 23 00 34 lwz r9,52(r3)
uint32_t cur_cln = 0;
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
ffc17758: 91 61 00 08 stw r11,8(r1)
if ( new_length >= fat_fd->fat_file_size )
ffc1775c: 40 9d 00 90 ble- cr7,ffc177ec <fat_file_truncate+0xd4> <== NEVER TAKEN
return rc;
assert(fat_fd->fat_file_size);
ffc17760: 2f 80 00 00 cmpwi cr7,r0,0
ffc17764: 41 9e 00 fc beq- cr7,ffc17860 <fat_file_truncate+0x148> <== NEVER TAKEN
cl_start = (new_length + fs_info->vol.bpc - 1) >> fs_info->vol.bpc_log2;
ffc17768: a3 a9 00 06 lhz r29,6(r9)
ffc1776c: 89 29 00 08 lbz r9,8(r9)
ffc17770: 3b bd ff ff addi r29,r29,-1
ffc17774: 7f bd 2a 14 add r29,r29,r5
ffc17778: 7f bd 4c 30 srw r29,r29,r9
if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size)
ffc1777c: 7f a9 48 30 slw r9,r29,r9
ffc17780: 7f 80 48 40 cmplw cr7,r0,r9
return RC_OK;
ffc17784: 38 00 00 00 li r0,0
assert(fat_fd->fat_file_size);
cl_start = (new_length + fs_info->vol.bpc - 1) >> fs_info->vol.bpc_log2;
if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size)
ffc17788: 40 9d 00 3c ble- cr7,ffc177c4 <fat_file_truncate+0xac> <== NEVER TAKEN
return RC_OK;
if (cl_start != 0)
ffc1778c: 2e 1d 00 00 cmpwi cr4,r29,0
ffc17790: 41 92 00 18 beq- cr4,ffc177a8 <fat_file_truncate+0x90> <== ALWAYS TAKEN
{
rc = fat_file_lseek(mt_entry, fat_fd, cl_start - 1, &new_last_cln);
ffc17794: 38 bd ff ff addi r5,r29,-1 <== NOT EXECUTED
ffc17798: 38 c1 00 08 addi r6,r1,8 <== NOT EXECUTED
ffc1779c: 4b ff f8 ad bl ffc17048 <fat_file_lseek> <== NOT EXECUTED
if (rc != RC_OK)
ffc177a0: 7c 80 23 79 mr. r0,r4 <== NOT EXECUTED
ffc177a4: 40 82 00 20 bne- ffc177c4 <fat_file_truncate+0xac> <== NOT EXECUTED
return rc;
}
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
ffc177a8: 7f e3 fb 78 mr r3,r31
ffc177ac: 7f c4 f3 78 mr r4,r30
ffc177b0: 7f a5 eb 78 mr r5,r29
ffc177b4: 38 c1 00 0c addi r6,r1,12
ffc177b8: 4b ff f8 91 bl ffc17048 <fat_file_lseek>
if (rc != RC_OK)
ffc177bc: 7c 80 23 79 mr. r0,r4
ffc177c0: 41 82 00 58 beq- ffc17818 <fat_file_truncate+0x100> <== ALWAYS TAKEN
fat_fd->map.file_cln = cl_start - 1;
fat_fd->map.disk_cln = new_last_cln;
fat_fd->map.last_cln = new_last_cln;
}
return RC_OK;
}
ffc177c4: 7c 03 03 78 mr r3,r0
ffc177c8: 80 01 00 2c lwz r0,44(r1)
ffc177cc: 81 81 00 18 lwz r12,24(r1)
ffc177d0: 7c 08 03 a6 mtlr r0
ffc177d4: 83 a1 00 1c lwz r29,28(r1)
ffc177d8: 83 c1 00 20 lwz r30,32(r1)
ffc177dc: 7d 80 81 20 mtcrf 8,r12
ffc177e0: 83 e1 00 24 lwz r31,36(r1)
ffc177e4: 38 21 00 28 addi r1,r1,40
ffc177e8: 4e 80 00 20 blr
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
if ( new_length >= fat_fd->fat_file_size )
return rc;
ffc177ec: 38 00 00 00 li r0,0 <== NOT EXECUTED
fat_fd->map.file_cln = cl_start - 1;
fat_fd->map.disk_cln = new_last_cln;
fat_fd->map.last_cln = new_last_cln;
}
return RC_OK;
}
ffc177f0: 81 81 00 18 lwz r12,24(r1) <== NOT EXECUTED
ffc177f4: 7c 03 03 78 mr r3,r0 <== NOT EXECUTED
ffc177f8: 80 01 00 2c lwz r0,44(r1) <== NOT EXECUTED
ffc177fc: 83 a1 00 1c lwz r29,28(r1) <== NOT EXECUTED
ffc17800: 7d 80 81 20 mtcrf 8,r12 <== NOT EXECUTED
ffc17804: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc17808: 83 c1 00 20 lwz r30,32(r1) <== NOT EXECUTED
ffc1780c: 83 e1 00 24 lwz r31,36(r1) <== NOT EXECUTED
ffc17810: 38 21 00 28 addi r1,r1,40 <== NOT EXECUTED
ffc17814: 4e 80 00 20 blr <== NOT EXECUTED
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
rc = fat_free_fat_clusters_chain(mt_entry, cur_cln);
ffc17818: 80 81 00 0c lwz r4,12(r1)
ffc1781c: 7f e3 fb 78 mr r3,r31
ffc17820: 48 00 a9 dd bl ffc221fc <fat_free_fat_clusters_chain>
if (rc != RC_OK)
ffc17824: 7c 60 1b 79 mr. r0,r3
ffc17828: 40 a2 ff 9c bne- ffc177c4 <fat_file_truncate+0xac> <== NEVER TAKEN
return rc;
if (cl_start != 0)
ffc1782c: 41 92 ff 98 beq+ cr4,ffc177c4 <fat_file_truncate+0xac> <== ALWAYS TAKEN
{
rc = fat_set_fat_cluster(mt_entry, new_last_cln, FAT_GENFAT_EOC);
ffc17830: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
ffc17834: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc17838: 38 a0 ff ff li r5,-1 <== NOT EXECUTED
ffc1783c: 48 00 a6 5d bl ffc21e98 <fat_set_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
ffc17840: 7c 60 1b 79 mr. r0,r3 <== NOT EXECUTED
ffc17844: 40 a2 ff 80 bne- ffc177c4 <fat_file_truncate+0xac> <== NOT EXECUTED
return rc;
fat_fd->map.file_cln = cl_start - 1;
fat_fd->map.disk_cln = new_last_cln;
ffc17848: 81 21 00 08 lwz r9,8(r1) <== NOT EXECUTED
if (cl_start != 0)
{
rc = fat_set_fat_cluster(mt_entry, new_last_cln, FAT_GENFAT_EOC);
if ( rc != RC_OK )
return rc;
fat_fd->map.file_cln = cl_start - 1;
ffc1784c: 3b bd ff ff addi r29,r29,-1 <== NOT EXECUTED
ffc17850: 93 be 00 34 stw r29,52(r30) <== NOT EXECUTED
fat_fd->map.disk_cln = new_last_cln;
ffc17854: 91 3e 00 38 stw r9,56(r30) <== NOT EXECUTED
fat_fd->map.last_cln = new_last_cln;
ffc17858: 91 3e 00 3c stw r9,60(r30) <== NOT EXECUTED
ffc1785c: 4b ff ff 68 b ffc177c4 <fat_file_truncate+0xac> <== NOT EXECUTED
if ( new_length >= fat_fd->fat_file_size )
return rc;
assert(fat_fd->fat_file_size);
ffc17860: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc17864: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
ffc17868: 3c c0 ff c3 lis r6,-61 <== NOT EXECUTED
ffc1786c: 38 63 50 fc addi r3,r3,20732 <== NOT EXECUTED
ffc17870: 38 80 02 6d li r4,621 <== NOT EXECUTED
ffc17874: 38 a5 50 e8 addi r5,r5,20712 <== NOT EXECUTED
ffc17878: 38 c6 51 44 addi r6,r6,20804 <== NOT EXECUTED
ffc1787c: 4b ff 04 15 bl ffc07c90 <__assert_func> <== NOT EXECUTED
ffc17cc0 <fat_file_write>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
ffc17cc0: 94 21 ff c0 stwu r1,-64(r1)
ffc17cc4: 7c 08 02 a6 mflr r0
uint32_t sec = 0;
uint32_t byte = 0;
uint32_t c = 0;
if ( count == 0 )
return cmpltd;
ffc17cc8: 39 20 00 00 li r9,0
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
ffc17ccc: 93 e1 00 3c stw r31,60(r1)
uint32_t save_ofs;
uint32_t sec = 0;
uint32_t byte = 0;
uint32_t c = 0;
if ( count == 0 )
ffc17cd0: 7c df 33 79 mr. r31,r6
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
ffc17cd4: 90 01 00 44 stw r0,68(r1)
int rc = 0;
ssize_t ret = 0;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
ffc17cd8: 38 00 00 00 li r0,0
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
ffc17cdc: 93 21 00 24 stw r25,36(r1)
ffc17ce0: 7c f9 3b 78 mr r25,r7
ffc17ce4: 93 61 00 2c stw r27,44(r1)
ffc17ce8: 7c 9b 23 78 mr r27,r4
ffc17cec: 93 81 00 30 stw r28,48(r1)
ffc17cf0: 7c bc 2b 78 mr r28,r5
ffc17cf4: 93 a1 00 34 stw r29,52(r1)
ffc17cf8: 93 c1 00 38 stw r30,56(r1)
ffc17cfc: 7c 7e 1b 78 mr r30,r3
ffc17d00: 92 c1 00 18 stw r22,24(r1)
ffc17d04: 92 e1 00 1c stw r23,28(r1)
ffc17d08: 93 01 00 20 stw r24,32(r1)
ffc17d0c: 93 41 00 28 stw r26,40(r1)
int rc = 0;
ssize_t ret = 0;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc17d10: 83 a3 00 34 lwz r29,52(r3)
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
ffc17d14: 90 01 00 0c stw r0,12(r1)
uint32_t cl_start = 0;
uint32_t ofs = 0;
uint32_t save_ofs;
uint32_t sec = 0;
uint32_t byte = 0;
uint32_t c = 0;
ffc17d18: 90 01 00 08 stw r0,8(r1)
if ( count == 0 )
ffc17d1c: 41 82 01 74 beq- ffc17e90 <fat_file_write+0x1d0> <== NEVER TAKEN
return cmpltd;
if ( start > fat_fd->fat_file_size )
ffc17d20: 80 04 00 18 lwz r0,24(r4)
ffc17d24: 7f 80 28 40 cmplw cr7,r0,r5
ffc17d28: 41 9c 02 14 blt- cr7,ffc17f3c <fat_file_write+0x27c> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EIO );
if ((count > fat_fd->size_limit) ||
ffc17d2c: 80 04 00 14 lwz r0,20(r4)
ffc17d30: 7f 9f 00 40 cmplw cr7,r31,r0
ffc17d34: 41 9d 02 08 bgt- cr7,ffc17f3c <fat_file_write+0x27c> <== NEVER TAKEN
(start > fat_fd->size_limit - count))
ffc17d38: 7c 1f 00 50 subf r0,r31,r0
return cmpltd;
if ( start > fat_fd->fat_file_size )
rtems_set_errno_and_return_minus_one( EIO );
if ((count > fat_fd->size_limit) ||
ffc17d3c: 7f 85 00 40 cmplw cr7,r5,r0
ffc17d40: 41 9d 01 fc bgt- cr7,ffc17f3c <fat_file_write+0x27c> <== NEVER TAKEN
(start > fat_fd->size_limit - count))
rtems_set_errno_and_return_minus_one( EIO );
rc = fat_file_extend(mt_entry, fat_fd, start + count, &c);
ffc17d44: 7f 5f 2a 14 add r26,r31,r5
ffc17d48: 7f 45 d3 78 mr r5,r26
ffc17d4c: 38 c1 00 08 addi r6,r1,8
ffc17d50: 4b ff fd 31 bl ffc17a80 <fat_file_extend>
if (rc != RC_OK)
ffc17d54: 7c 69 1b 79 mr. r9,r3
ffc17d58: 40 82 01 38 bne- ffc17e90 <fat_file_write+0x1d0> <== NEVER TAKEN
/*
* check whether there was enough room on device to locate
* file of 'start + count' bytes
*/
if (c != (start + count))
ffc17d5c: 80 01 00 08 lwz r0,8(r1)
ffc17d60: 7f 9a 00 00 cmpw cr7,r26,r0
ffc17d64: 41 9e 00 08 beq- cr7,ffc17d6c <fat_file_write+0xac> <== ALWAYS TAKEN
count = c - start;
ffc17d68: 7f fc 00 50 subf r31,r28,r0 <== NOT EXECUTED
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
ffc17d6c: 80 1b 00 20 lwz r0,32(r27)
ffc17d70: 2f 80 00 01 cmpwi cr7,r0,1
ffc17d74: 41 9e 01 58 beq- cr7,ffc17ecc <fat_file_write+0x20c>
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
ffc17d78: 8b 1d 00 08 lbz r24,8(r29)
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
ffc17d7c: 7f c3 f3 78 mr r3,r30
ffc17d80: 7f 64 db 78 mr r4,r27
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
ffc17d84: a3 5d 00 06 lhz r26,6(r29)
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
ffc17d88: 7f 98 c4 30 srw r24,r28,r24
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
ffc17d8c: 7f 05 c3 78 mr r5,r24
ffc17d90: 38 c1 00 0c addi r6,r1,12
ffc17d94: 4b ff f2 b5 bl ffc17048 <fat_file_lseek>
if (rc != RC_OK)
ffc17d98: 7c 89 23 79 mr. r9,r4
ffc17d9c: 40 82 00 f4 bne- ffc17e90 <fat_file_write+0x1d0> <== NEVER TAKEN
return rc;
while (count > 0)
ffc17da0: 2f 9f 00 00 cmpwi cr7,r31,0
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
ffc17da4: 3b 5a ff ff addi r26,r26,-1
ffc17da8: 7f 9c d0 38 and r28,r28,r26
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
ffc17dac: 3a c0 00 00 li r22,0
ffc17db0: 7f 8b e3 78 mr r11,r28
ffc17db4: 3b 40 00 00 li r26,0
ffc17db8: 40 be 00 78 bne+ cr7,ffc17e30 <fat_file_write+0x170> <== ALWAYS TAKEN
ffc17dbc: 48 00 00 b8 b ffc17e74 <fat_file_write+0x1b4> <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
ffc17dc0: 88 09 00 0a lbz r0,10(r9) <== NOT EXECUTED
ffc17dc4: 70 0a 00 03 andi. r10,r0,3 <== NOT EXECUTED
ffc17dc8: 41 82 00 94 beq- ffc17e5c <fat_file_write+0x19c> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
ffc17dcc: 80 89 00 1c lwz r4,28(r9) <== NOT EXECUTED
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
ffc17dd0: 88 1d 00 02 lbz r0,2(r29)
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
ffc17dd4: 7c f9 d2 14 add r7,r25,r26
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ffc17dd8: a0 bd 00 00 lhz r5,0(r29)
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
ffc17ddc: 7f c3 f3 78 mr r3,r30
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
ffc17de0: 7d 60 04 30 srw r0,r11,r0
byte = ofs & (fs_info->vol.bps - 1);
ffc17de4: 38 a5 ff ff addi r5,r5,-1
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
ffc17de8: 7d 65 28 38 and r5,r11,r5
ffc17dec: 7c 84 02 14 add r4,r4,r0
ffc17df0: 48 00 09 95 bl ffc18784 <_fat_block_write>
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
ffc17df4: 38 a1 00 0c addi r5,r1,12
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
ffc17df8: 2f 83 00 00 cmpwi cr7,r3,0
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
ffc17dfc: 7f c3 f3 78 mr r3,r30
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
ffc17e00: 41 9c 01 34 blt- cr7,ffc17f34 <fat_file_write+0x274> <== NEVER TAKEN
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
ffc17e04: 82 c1 00 0c lwz r22,12(r1)
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
count -= c;
ffc17e08: 82 e1 00 08 lwz r23,8(r1)
cmpltd += c;
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
ffc17e0c: 7e c4 b3 78 mr r4,r22
ffc17e10: 48 00 9e 25 bl ffc21c34 <fat_get_fat_cluster>
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
ffc17e14: 7f f7 f8 50 subf r31,r23,r31
count -= c;
cmpltd += c;
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
if ( rc != RC_OK )
ffc17e18: 7c 69 1b 79 mr. r9,r3
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
ffc17e1c: 2f 9f 00 00 cmpwi cr7,r31,0
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
count -= c;
cmpltd += c;
ffc17e20: 7f 5a ba 14 add r26,r26,r23
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
if ( rc != RC_OK )
return rc;
ofs = 0;
ffc17e24: 39 60 00 00 li r11,0
count -= c;
cmpltd += c;
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
if ( rc != RC_OK )
ffc17e28: 40 82 00 68 bne- ffc17e90 <fat_file_write+0x1d0> <== NEVER TAKEN
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
ffc17e2c: 41 9e 00 44 beq- cr7,ffc17e70 <fat_file_write+0x1b0>
{
c = MIN(count, (fs_info->vol.bpc - ofs));
ffc17e30: a0 dd 00 06 lhz r6,6(r29)
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
ffc17e34: 80 81 00 0c lwz r4,12(r1)
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
ffc17e38: 7c cb 30 50 subf r6,r11,r6
ffc17e3c: 7f 06 f8 40 cmplw cr6,r6,r31
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
ffc17e40: 2f 84 00 00 cmpwi cr7,r4,0
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
ffc17e44: 38 84 ff fe addi r4,r4,-2
ffc17e48: 40 99 00 08 ble- cr6,ffc17e50 <fat_file_write+0x190>
ffc17e4c: 7f e6 fb 78 mr r6,r31
fat_fd->map.disk_cln = cur_cln;
*disk_cln = cur_cln;
}
return RC_OK;
}
ffc17e50: 81 3e 00 34 lwz r9,52(r30)
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
ffc17e54: 90 c1 00 08 stw r6,8(r1)
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
ffc17e58: 41 be ff 68 beq- cr7,ffc17dc0 <fat_file_write+0x100> <== NEVER TAKEN
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
ffc17e5c: 89 49 00 05 lbz r10,5(r9)
ffc17e60: 80 09 00 30 lwz r0,48(r9)
ffc17e64: 7c 84 50 30 slw r4,r4,r10
ffc17e68: 7c 84 02 14 add r4,r4,r0
ffc17e6c: 4b ff ff 64 b ffc17dd0 <fat_file_write+0x110>
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
ffc17e70: 7f 49 d3 78 mr r9,r26
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
ffc17e74: 88 1d 00 08 lbz r0,8(r29)
ffc17e78: 3b 9c ff ff addi r28,r28,-1
ffc17e7c: 7f 5c d2 14 add r26,r28,r26
fat_fd->map.disk_cln = save_cln;
ffc17e80: 92 db 00 38 stw r22,56(r27)
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
ffc17e84: 7f 5a 04 30 srw r26,r26,r0
ofs = 0;
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
ffc17e88: 7f 1a c2 14 add r24,r26,r24
ffc17e8c: 93 1b 00 34 stw r24,52(r27)
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
}
ffc17e90: 80 01 00 44 lwz r0,68(r1)
ffc17e94: 7d 23 4b 78 mr r3,r9
ffc17e98: 82 c1 00 18 lwz r22,24(r1)
ffc17e9c: 7c 08 03 a6 mtlr r0
ffc17ea0: 82 e1 00 1c lwz r23,28(r1)
ffc17ea4: 83 01 00 20 lwz r24,32(r1)
ffc17ea8: 83 21 00 24 lwz r25,36(r1)
ffc17eac: 83 41 00 28 lwz r26,40(r1)
ffc17eb0: 83 61 00 2c lwz r27,44(r1)
ffc17eb4: 83 81 00 30 lwz r28,48(r1)
ffc17eb8: 83 a1 00 34 lwz r29,52(r1)
ffc17ebc: 83 c1 00 38 lwz r30,56(r1)
ffc17ec0: 83 e1 00 3c lwz r31,60(r1)
ffc17ec4: 38 21 00 40 addi r1,r1,64
ffc17ec8: 4e 80 00 20 blr
* file of 'start + count' bytes
*/
if (c != (start + count))
count = c - start;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
ffc17ecc: 80 1b 00 24 lwz r0,36(r27)
ffc17ed0: 2f 80 00 00 cmpwi cr7,r0,0
ffc17ed4: 40 be fe a4 bne- cr7,ffc17d78 <fat_file_write+0xb8> <== NEVER TAKEN
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
ffc17ed8: 88 1d 00 0a lbz r0,10(r29)
* file of 'start + count' bytes
*/
if (c != (start + count))
count = c - start;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
ffc17edc: 70 09 00 03 andi. r9,r0,3
ffc17ee0: 41 a2 fe 98 beq- ffc17d78 <fat_file_write+0xb8> <== NEVER TAKEN
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
ffc17ee4: 81 7b 00 1c lwz r11,28(r27)
fat_fd->map.disk_cln = cur_cln;
*disk_cln = cur_cln;
}
return RC_OK;
}
ffc17ee8: 81 3e 00 34 lwz r9,52(r30)
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
ffc17eec: 2f 8b 00 00 cmpwi cr7,r11,0
ffc17ef0: 40 9e 00 60 bne- cr7,ffc17f50 <fat_file_write+0x290> <== NEVER TAKEN
ffc17ef4: 88 09 00 0a lbz r0,10(r9)
ffc17ef8: 70 0a 00 03 andi. r10,r0,3
ffc17efc: 41 82 00 54 beq- ffc17f50 <fat_file_write+0x290> <== NEVER TAKEN
return fs_info->vol.rdir_loc;
ffc17f00: 80 89 00 1c lwz r4,28(r9)
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
ffc17f04: 88 1d 00 02 lbz r0,2(r29)
byte = start & (fs_info->vol.bps - 1);
ret = _fat_block_write(mt_entry, sec, byte, count, buf);
ffc17f08: 7f c3 f3 78 mr r3,r30
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
byte = start & (fs_info->vol.bps - 1);
ffc17f0c: a0 bd 00 00 lhz r5,0(r29)
ret = _fat_block_write(mt_entry, sec, byte, count, buf);
ffc17f10: 7f e6 fb 78 mr r6,r31
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
ffc17f14: 7f 80 04 30 srw r0,r28,r0
byte = start & (fs_info->vol.bps - 1);
ffc17f18: 38 a5 ff ff addi r5,r5,-1
ret = _fat_block_write(mt_entry, sec, byte, count, buf);
ffc17f1c: 7c 84 02 14 add r4,r4,r0
ffc17f20: 7f 85 28 38 and r5,r28,r5
ffc17f24: 7f 27 cb 78 mr r7,r25
ffc17f28: 48 00 08 5d bl ffc18784 <_fat_block_write>
if ( ret < 0 )
ffc17f2c: 7c 69 1b 79 mr. r9,r3
ffc17f30: 40 80 ff 60 bge+ ffc17e90 <fat_file_write+0x1d0> <== ALWAYS TAKEN
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
ffc17f34: 39 20 ff ff li r9,-1 <== NOT EXECUTED
ffc17f38: 4b ff ff 58 b ffc17e90 <fat_file_write+0x1d0> <== NOT EXECUTED
if ( start > fat_fd->fat_file_size )
rtems_set_errno_and_return_minus_one( EIO );
if ((count > fat_fd->size_limit) ||
(start > fat_fd->size_limit - count))
rtems_set_errno_and_return_minus_one( EIO );
ffc17f3c: 48 00 c2 d5 bl ffc24210 <__errno> <== NOT EXECUTED
ffc17f40: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc17f44: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc17f48: 39 20 ff ff li r9,-1 <== NOT EXECUTED
ffc17f4c: 4b ff ff 44 b ffc17e90 <fat_file_write+0x1d0> <== NOT EXECUTED
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
ffc17f50: 89 49 00 05 lbz r10,5(r9) <== NOT EXECUTED
ffc17f54: 38 8b ff fe addi r4,r11,-2 <== NOT EXECUTED
ffc17f58: 80 09 00 30 lwz r0,48(r9) <== NOT EXECUTED
ffc17f5c: 7c 84 50 30 slw r4,r4,r10 <== NOT EXECUTED
ffc17f60: 7c 84 02 14 add r4,r4,r0 <== NOT EXECUTED
ffc17f64: 4b ff ff a0 b ffc17f04 <fat_file_write+0x244> <== NOT EXECUTED
ffc221fc <fat_free_fat_clusters_chain>:
int
fat_free_fat_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t chain
)
{
ffc221fc: 94 21 ff d0 stwu r1,-48(r1)
ffc22200: 7c 08 02 a6 mflr r0
ffc22204: 90 01 00 34 stw r0,52(r1)
ffc22208: 93 c1 00 28 stw r30,40(r1)
int rc = RC_OK, rc1 = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc2220c: 83 c3 00 34 lwz r30,52(r3)
int
fat_free_fat_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t chain
)
{
ffc22210: 93 41 00 18 stw r26,24(r1)
ffc22214: 7c 9a 23 78 mr r26,r4
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
ffc22218: 81 3e 00 0c lwz r9,12(r30)
ffc2221c: 80 1e 00 10 lwz r0,16(r30)
ffc22220: 7c 89 48 38 and r9,r4,r9
int
fat_free_fat_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t chain
)
{
ffc22224: 93 a1 00 24 stw r29,36(r1)
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
ffc22228: 7f 89 00 40 cmplw cr7,r9,r0
)
{
int rc = RC_OK, rc1 = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
ffc2222c: 38 00 00 00 li r0,0
int
fat_free_fat_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t chain
)
{
ffc22230: 93 61 00 1c stw r27,28(r1)
ffc22234: 7c 7d 1b 78 mr r29,r3
ffc22238: 93 81 00 20 stw r28,32(r1)
ffc2223c: 93 e1 00 2c stw r31,44(r1)
int rc = RC_OK, rc1 = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
ffc22240: 90 01 00 08 stw r0,8(r1)
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
ffc22244: 40 9c 00 ac bge- cr7,ffc222f0 <fat_free_fat_clusters_chain+0xf4><== NEVER TAKEN
ffc22248: 7c 9f 23 78 mr r31,r4
ffc2224c: 3b 80 00 00 li r28,0
ffc22250: 3b 60 00 00 li r27,0
ffc22254: 48 00 00 30 b ffc22284 <fat_free_fat_clusters_chain+0x88>
fat_buf_release(fs_info);
return rc;
}
rc = fat_set_fat_cluster(mt_entry, cur_cln, FAT_GENFAT_FREE);
ffc22258: 4b ff fc 41 bl ffc21e98 <fat_set_fat_cluster>
if ( rc != RC_OK )
rc1 = rc;
freed_cls_cnt++;
ffc2225c: 3b 9c 00 01 addi r28,r28,1
fat_buf_release(fs_info);
return rc;
}
rc = fat_set_fat_cluster(mt_entry, cur_cln, FAT_GENFAT_FREE);
if ( rc != RC_OK )
ffc22260: 2c 03 00 00 cmpwi r3,0
rc1 = rc;
freed_cls_cnt++;
cur_cln = next_cln;
ffc22264: 83 e1 00 08 lwz r31,8(r1)
fat_buf_release(fs_info);
return rc;
}
rc = fat_set_fat_cluster(mt_entry, cur_cln, FAT_GENFAT_FREE);
if ( rc != RC_OK )
ffc22268: 41 82 00 08 beq- ffc22270 <fat_free_fat_clusters_chain+0x74><== ALWAYS TAKEN
ffc2226c: 7c 7b 1b 78 mr r27,r3 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
ffc22270: 81 3e 00 0c lwz r9,12(r30)
ffc22274: 80 1e 00 10 lwz r0,16(r30)
ffc22278: 7f e9 48 38 and r9,r31,r9
ffc2227c: 7f 89 00 40 cmplw cr7,r9,r0
ffc22280: 40 9c 00 78 bge- cr7,ffc222f8 <fat_free_fat_clusters_chain+0xfc><== ALWAYS TAKEN
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &next_cln);
ffc22284: 7f e4 fb 78 mr r4,r31
ffc22288: 38 a1 00 08 addi r5,r1,8
ffc2228c: 7f a3 eb 78 mr r3,r29
ffc22290: 4b ff f9 a5 bl ffc21c34 <fat_get_fat_cluster>
fat_buf_release(fs_info);
return rc;
}
rc = fat_set_fat_cluster(mt_entry, cur_cln, FAT_GENFAT_FREE);
ffc22294: 7f e4 fb 78 mr r4,r31
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &next_cln);
if ( rc != RC_OK )
ffc22298: 7c 7f 1b 79 mr. r31,r3
fat_buf_release(fs_info);
return rc;
}
rc = fat_set_fat_cluster(mt_entry, cur_cln, FAT_GENFAT_FREE);
ffc2229c: 38 a0 00 00 li r5,0
ffc222a0: 7f a3 eb 78 mr r3,r29
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &next_cln);
if ( rc != RC_OK )
ffc222a4: 41 82 ff b4 beq+ ffc22258 <fat_free_fat_clusters_chain+0x5c><== ALWAYS TAKEN
{
if(fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
ffc222a8: 80 1e 00 40 lwz r0,64(r30) <== NOT EXECUTED
ffc222ac: 2f 80 ff ff cmpwi cr7,r0,-1 <== NOT EXECUTED
ffc222b0: 41 9e 00 0c beq- cr7,ffc222bc <fat_free_fat_clusters_chain+0xc0><== NOT EXECUTED
fs_info->vol.free_cls += freed_cls_cnt;
ffc222b4: 7c 1c 02 14 add r0,r28,r0 <== NOT EXECUTED
ffc222b8: 90 1e 00 40 stw r0,64(r30) <== NOT EXECUTED
fat_buf_release(fs_info);
ffc222bc: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc222c0: 4b ff 62 41 bl ffc18500 <fat_buf_release> <== NOT EXECUTED
fat_buf_release(fs_info);
if (rc1 != RC_OK)
return rc1;
return RC_OK;
}
ffc222c4: 80 01 00 34 lwz r0,52(r1) <== NOT EXECUTED
ffc222c8: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc222cc: 83 41 00 18 lwz r26,24(r1) <== NOT EXECUTED
ffc222d0: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc222d4: 83 61 00 1c lwz r27,28(r1) <== NOT EXECUTED
ffc222d8: 83 81 00 20 lwz r28,32(r1) <== NOT EXECUTED
ffc222dc: 83 a1 00 24 lwz r29,36(r1) <== NOT EXECUTED
ffc222e0: 83 c1 00 28 lwz r30,40(r1) <== NOT EXECUTED
ffc222e4: 83 e1 00 2c lwz r31,44(r1) <== NOT EXECUTED
ffc222e8: 38 21 00 30 addi r1,r1,48 <== NOT EXECUTED
ffc222ec: 4e 80 00 20 blr <== NOT EXECUTED
{
int rc = RC_OK, rc1 = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
ffc222f0: 3b 80 00 00 li r28,0 <== NOT EXECUTED
fat_free_fat_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t chain
)
{
int rc = RC_OK, rc1 = RC_OK;
ffc222f4: 3b 60 00 00 li r27,0 <== NOT EXECUTED
freed_cls_cnt++;
cur_cln = next_cln;
}
fs_info->vol.next_cl = chain;
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
ffc222f8: 80 1e 00 40 lwz r0,64(r30)
freed_cls_cnt++;
cur_cln = next_cln;
}
fs_info->vol.next_cl = chain;
ffc222fc: 93 5e 00 44 stw r26,68(r30)
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
ffc22300: 2f 80 ff ff cmpwi cr7,r0,-1
ffc22304: 41 9e 00 0c beq- cr7,ffc22310 <fat_free_fat_clusters_chain+0x114><== ALWAYS TAKEN
fs_info->vol.free_cls += freed_cls_cnt;
ffc22308: 7c 1c 02 14 add r0,r28,r0 <== NOT EXECUTED
ffc2230c: 90 1e 00 40 stw r0,64(r30) <== NOT EXECUTED
fat_buf_release(fs_info);
ffc22310: 7f c3 f3 78 mr r3,r30
ffc22314: 4b ff 61 ed bl ffc18500 <fat_buf_release>
if (rc1 != RC_OK)
return rc1;
return RC_OK;
}
ffc22318: 80 01 00 34 lwz r0,52(r1)
fs_info->vol.next_cl = chain;
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
fs_info->vol.free_cls += freed_cls_cnt;
fat_buf_release(fs_info);
ffc2231c: 7f 7f db 78 mr r31,r27
if (rc1 != RC_OK)
return rc1;
return RC_OK;
}
ffc22320: 83 41 00 18 lwz r26,24(r1)
ffc22324: 7c 08 03 a6 mtlr r0
ffc22328: 7f e3 fb 78 mr r3,r31
ffc2232c: 83 61 00 1c lwz r27,28(r1)
ffc22330: 83 81 00 20 lwz r28,32(r1)
ffc22334: 83 a1 00 24 lwz r29,36(r1)
ffc22338: 83 c1 00 28 lwz r30,40(r1)
ffc2233c: 83 e1 00 2c lwz r31,44(r1)
ffc22340: 38 21 00 30 addi r1,r1,48
ffc22344: 4e 80 00 20 blr
ffc18bbc <fat_free_unique_ino>:
fat_free_unique_ino(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t ino
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc18bbc: 81 23 00 34 lwz r9,52(r3) <== NOT EXECUTED
FAT_SET_UNIQ_INO_FREE((ino - fs_info->uino_base), fs_info->uino);
ffc18bc0: 39 00 ff fe li r8,-2 <== NOT EXECUTED
ffc18bc4: 80 09 00 7c lwz r0,124(r9) <== NOT EXECUTED
ffc18bc8: 81 29 00 70 lwz r9,112(r9) <== NOT EXECUTED
ffc18bcc: 7c 00 20 50 subf r0,r0,r4 <== NOT EXECUTED
ffc18bd0: 54 0b e8 fe rlwinm r11,r0,29,3,31 <== NOT EXECUTED
ffc18bd4: 7d 49 58 ae lbzx r10,r9,r11 <== NOT EXECUTED
ffc18bd8: 54 00 07 7e clrlwi r0,r0,29 <== NOT EXECUTED
ffc18bdc: 5d 00 00 3e rotlw r0,r8,r0 <== NOT EXECUTED
ffc18be0: 7c 00 50 38 and r0,r0,r10 <== NOT EXECUTED
ffc18be4: 7c 09 59 ae stbx r0,r9,r11 <== NOT EXECUTED
}
ffc18be8: 4e 80 00 20 blr <== NOT EXECUTED
ffc21c34 <fat_get_fat_cluster>:
rtems_bdbuf_buffer *block0 = NULL;
uint32_t sec = 0;
uint32_t ofs = 0;
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
ffc21c34: 2b 84 00 01 cmplwi cr7,r4,1
fat_get_fat_cluster(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
uint32_t *ret_val
)
{
ffc21c38: 94 21 ff c8 stwu r1,-56(r1)
ffc21c3c: 7c 08 02 a6 mflr r0
ffc21c40: 93 41 00 20 stw r26,32(r1)
ffc21c44: 7c ba 2b 78 mr r26,r5
ffc21c48: 90 01 00 3c stw r0,60(r1)
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
rtems_bdbuf_buffer *block0 = NULL;
ffc21c4c: 38 00 00 00 li r0,0
fat_get_fat_cluster(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
uint32_t *ret_val
)
{
ffc21c50: 93 c1 00 30 stw r30,48(r1)
ffc21c54: 7c 9e 23 78 mr r30,r4
ffc21c58: 93 e1 00 34 stw r31,52(r1)
ffc21c5c: 93 21 00 1c stw r25,28(r1)
ffc21c60: 93 61 00 24 stw r27,36(r1)
ffc21c64: 93 81 00 28 stw r28,40(r1)
ffc21c68: 93 a1 00 2c stw r29,44(r1)
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc21c6c: 83 e3 00 34 lwz r31,52(r3)
rtems_bdbuf_buffer *block0 = NULL;
ffc21c70: 90 01 00 08 stw r0,8(r1)
uint32_t sec = 0;
uint32_t ofs = 0;
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
ffc21c74: 40 9d 00 80 ble- cr7,ffc21cf4 <fat_get_fat_cluster+0xc0><== NEVER TAKEN
ffc21c78: 81 3f 00 34 lwz r9,52(r31)
ffc21c7c: 38 09 00 01 addi r0,r9,1
ffc21c80: 7f 84 00 40 cmplw cr7,r4,r0
ffc21c84: 41 9d 00 70 bgt- cr7,ffc21cf4 <fat_get_fat_cluster+0xc0><== NEVER TAKEN
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
ffc21c88: 88 1f 00 0a lbz r0,10(r31)
ffc21c8c: 70 09 00 01 andi. r9,r0,1
ffc21c90: 40 82 00 a4 bne- ffc21d34 <fat_get_fat_cluster+0x100> <== ALWAYS TAKEN
ffc21c94: 70 09 00 02 andi. r9,r0,2 <== NOT EXECUTED
ffc21c98: 8b 7f 00 02 lbz r27,2(r31) <== NOT EXECUTED
ffc21c9c: 41 82 00 b4 beq- ffc21d50 <fat_get_fat_cluster+0x11c> <== NOT EXECUTED
ffc21ca0: 54 9d 08 3c rlwinm r29,r4,1,0,30 <== NOT EXECUTED
ffc21ca4: 80 1f 00 4c lwz r0,76(r31) <== NOT EXECUTED
ffc21ca8: 7f bb dc 30 srw r27,r29,r27 <== NOT EXECUTED
ffc21cac: 7f 7b 02 14 add r27,r27,r0 <== NOT EXECUTED
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
ffc21cb0: 7f e3 fb 78 mr r3,r31
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
ffc21cb4: a3 3f 00 00 lhz r25,0(r31)
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
ffc21cb8: 7f 64 db 78 mr r4,r27
ffc21cbc: 38 a0 00 01 li r5,1
ffc21cc0: 38 c1 00 08 addi r6,r1,8
ffc21cc4: 4b ff 65 f5 bl ffc182b8 <fat_buf_access>
if (rc != RC_OK)
ffc21cc8: 7c 7c 1b 79 mr. r28,r3
ffc21ccc: 40 82 00 38 bne- ffc21d04 <fat_get_fat_cluster+0xd0> <== NEVER TAKEN
return rc;
switch ( fs_info->vol.type )
ffc21cd0: 88 1f 00 0a lbz r0,10(r31)
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
ffc21cd4: 3b 39 ff ff addi r25,r25,-1
ffc21cd8: 7f bd c8 38 and r29,r29,r25
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
if (rc != RC_OK)
return rc;
switch ( fs_info->vol.type )
ffc21cdc: 2f 80 00 02 cmpwi cr7,r0,2
ffc21ce0: 41 9e 00 84 beq- cr7,ffc21d64 <fat_get_fat_cluster+0x130><== NEVER TAKEN
ffc21ce4: 2f 80 00 04 cmpwi cr7,r0,4
ffc21ce8: 41 9e 01 10 beq- cr7,ffc21df8 <fat_get_fat_cluster+0x1c4><== NEVER TAKEN
ffc21cec: 2f 80 00 01 cmpwi cr7,r0,1
ffc21cf0: 41 9e 00 c0 beq- cr7,ffc21db0 <fat_get_fat_cluster+0x17c><== ALWAYS TAKEN
*ret_val = *((uint32_t *)(block0->buffer + ofs));
*ret_val = CF_LE_L(*ret_val);
break;
default:
rtems_set_errno_and_return_minus_one(EIO);
ffc21cf4: 48 00 25 1d bl ffc24210 <__errno> <== NOT EXECUTED
ffc21cf8: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc21cfc: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc21d00: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
break;
}
return RC_OK;
}
ffc21d04: 80 01 00 3c lwz r0,60(r1)
ffc21d08: 7f 83 e3 78 mr r3,r28
ffc21d0c: 83 21 00 1c lwz r25,28(r1)
ffc21d10: 7c 08 03 a6 mtlr r0
ffc21d14: 83 41 00 20 lwz r26,32(r1)
ffc21d18: 83 61 00 24 lwz r27,36(r1)
ffc21d1c: 83 81 00 28 lwz r28,40(r1)
ffc21d20: 83 a1 00 2c lwz r29,44(r1)
ffc21d24: 83 c1 00 30 lwz r30,48(r1)
ffc21d28: 83 e1 00 34 lwz r31,52(r1)
ffc21d2c: 38 21 00 38 addi r1,r1,56
ffc21d30: 4e 80 00 20 blr
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
ffc21d34: 54 9d f8 7e rlwinm r29,r4,31,1,31
ffc21d38: 8b 7f 00 02 lbz r27,2(r31)
ffc21d3c: 7f bd 22 14 add r29,r29,r4
ffc21d40: 80 1f 00 4c lwz r0,76(r31)
ffc21d44: 7f bb dc 30 srw r27,r29,r27
ffc21d48: 7f 7b 02 14 add r27,r27,r0
ffc21d4c: 4b ff ff 64 b ffc21cb0 <fat_get_fat_cluster+0x7c>
ffc21d50: 54 9d 10 3a rlwinm r29,r4,2,0,29 <== NOT EXECUTED
ffc21d54: 80 1f 00 4c lwz r0,76(r31) <== NOT EXECUTED
ffc21d58: 7f bb dc 30 srw r27,r29,r27 <== NOT EXECUTED
ffc21d5c: 7f 7b 02 14 add r27,r27,r0 <== NOT EXECUTED
ffc21d60: 4b ff ff 50 b ffc21cb0 <fat_get_fat_cluster+0x7c> <== NOT EXECUTED
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
break;
case FAT_FAT16:
*ret_val = *((uint16_t *)(block0->buffer + ofs));
ffc21d64: 81 21 00 08 lwz r9,8(r1) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
break;
}
return RC_OK;
}
ffc21d68: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc21d6c: 83 21 00 1c lwz r25,28(r1) <== NOT EXECUTED
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
break;
case FAT_FAT16:
*ret_val = *((uint16_t *)(block0->buffer + ofs));
ffc21d70: 81 29 00 24 lwz r9,36(r9) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
break;
}
return RC_OK;
}
ffc21d74: 83 61 00 24 lwz r27,36(r1) <== NOT EXECUTED
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
break;
case FAT_FAT16:
*ret_val = *((uint16_t *)(block0->buffer + ofs));
ffc21d78: 7c 09 ea 2e lhzx r0,r9,r29 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
break;
}
return RC_OK;
}
ffc21d7c: 83 81 00 28 lwz r28,40(r1) <== NOT EXECUTED
*ret_val = (*ret_val) & FAT_FAT12_MASK;
break;
case FAT_FAT16:
*ret_val = *((uint16_t *)(block0->buffer + ofs));
*ret_val = CF_LE_W(*ret_val);
ffc21d80: 54 09 c2 3e rlwinm r9,r0,24,8,31 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
break;
}
return RC_OK;
}
ffc21d84: 83 a1 00 2c lwz r29,44(r1) <== NOT EXECUTED
*ret_val = (*ret_val) & FAT_FAT12_MASK;
break;
case FAT_FAT16:
*ret_val = *((uint16_t *)(block0->buffer + ofs));
*ret_val = CF_LE_W(*ret_val);
ffc21d88: 54 00 44 2e rlwinm r0,r0,8,16,23 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
break;
}
return RC_OK;
}
ffc21d8c: 83 c1 00 30 lwz r30,48(r1) <== NOT EXECUTED
*ret_val = (*ret_val) & FAT_FAT12_MASK;
break;
case FAT_FAT16:
*ret_val = *((uint16_t *)(block0->buffer + ofs));
*ret_val = CF_LE_W(*ret_val);
ffc21d90: 7d 20 03 78 or r0,r9,r0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
break;
}
return RC_OK;
}
ffc21d94: 83 e1 00 34 lwz r31,52(r1) <== NOT EXECUTED
*ret_val = (*ret_val) & FAT_FAT12_MASK;
break;
case FAT_FAT16:
*ret_val = *((uint16_t *)(block0->buffer + ofs));
*ret_val = CF_LE_W(*ret_val);
ffc21d98: 90 1a 00 00 stw r0,0(r26) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
break;
}
return RC_OK;
}
ffc21d9c: 80 01 00 3c lwz r0,60(r1) <== NOT EXECUTED
ffc21da0: 83 41 00 20 lwz r26,32(r1) <== NOT EXECUTED
ffc21da4: 38 21 00 38 addi r1,r1,56 <== NOT EXECUTED
ffc21da8: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc21dac: 4e 80 00 20 blr <== NOT EXECUTED
/*
* we are enforced in complex computations for FAT12 to escape CPU
* align problems for some architectures
*/
*ret_val = (*((uint8_t *)(block0->buffer + ofs)));
if ( ofs == (fs_info->vol.bps - 1) )
ffc21db0: a1 3f 00 00 lhz r9,0(r31)
ffc21db4: 38 09 ff ff addi r0,r9,-1
case FAT_FAT12:
/*
* we are enforced in complex computations for FAT12 to escape CPU
* align problems for some architectures
*/
*ret_val = (*((uint8_t *)(block0->buffer + ofs)));
ffc21db8: 81 21 00 08 lwz r9,8(r1)
if ( ofs == (fs_info->vol.bps - 1) )
ffc21dbc: 7f 80 e8 00 cmpw cr7,r0,r29
case FAT_FAT12:
/*
* we are enforced in complex computations for FAT12 to escape CPU
* align problems for some architectures
*/
*ret_val = (*((uint8_t *)(block0->buffer + ofs)));
ffc21dc0: 81 29 00 24 lwz r9,36(r9)
ffc21dc4: 7c 09 e8 ae lbzx r0,r9,r29
ffc21dc8: 90 1a 00 00 stw r0,0(r26)
if ( ofs == (fs_info->vol.bps - 1) )
ffc21dcc: 41 9e 00 88 beq- cr7,ffc21e54 <fat_get_fat_cluster+0x220><== NEVER TAKEN
*ret_val |= (*((uint8_t *)(block0->buffer)))<<8;
}
else
{
*ret_val |= (*((uint8_t *)(block0->buffer + ofs + 1)))<<8;
ffc21dd0: 7f a9 ea 14 add r29,r9,r29
ffc21dd4: 89 3d 00 01 lbz r9,1(r29)
ffc21dd8: 55 29 40 2e rlwinm r9,r9,8,0,23
ffc21ddc: 7d 20 03 78 or r0,r9,r0
ffc21de0: 90 1a 00 00 stw r0,0(r26)
}
if ( FAT_CLUSTER_IS_ODD(cln) )
ffc21de4: 73 c9 00 01 andi. r9,r30,1
ffc21de8: 41 82 00 60 beq- ffc21e48 <fat_get_fat_cluster+0x214>
*ret_val = (*ret_val) >> FAT12_SHIFT;
ffc21dec: 54 00 e1 3e rlwinm r0,r0,28,4,31
ffc21df0: 90 1a 00 00 stw r0,0(r26)
ffc21df4: 4b ff ff 10 b ffc21d04 <fat_get_fat_cluster+0xd0>
*ret_val = *((uint16_t *)(block0->buffer + ofs));
*ret_val = CF_LE_W(*ret_val);
break;
case FAT_FAT32:
*ret_val = *((uint32_t *)(block0->buffer + ofs));
ffc21df8: 81 21 00 08 lwz r9,8(r1) <== NOT EXECUTED
ffc21dfc: 81 29 00 24 lwz r9,36(r9) <== NOT EXECUTED
ffc21e00: 7d 29 e8 2e lwzx r9,r9,r29 <== NOT EXECUTED
ffc21e04: 51 20 46 3e rlwimi r0,r9,8,24,31 <== NOT EXECUTED
ffc21e08: 51 20 c4 2e rlwimi r0,r9,24,16,23 <== NOT EXECUTED
ffc21e0c: 51 20 42 1e rlwimi r0,r9,8,8,15 <== NOT EXECUTED
ffc21e10: 51 20 c0 0e rlwimi r0,r9,24,0,7 <== NOT EXECUTED
*ret_val = CF_LE_L(*ret_val);
ffc21e14: 90 1a 00 00 stw r0,0(r26) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
break;
}
return RC_OK;
}
ffc21e18: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc21e1c: 80 01 00 3c lwz r0,60(r1) <== NOT EXECUTED
ffc21e20: 83 21 00 1c lwz r25,28(r1) <== NOT EXECUTED
ffc21e24: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc21e28: 83 41 00 20 lwz r26,32(r1) <== NOT EXECUTED
ffc21e2c: 83 61 00 24 lwz r27,36(r1) <== NOT EXECUTED
ffc21e30: 83 81 00 28 lwz r28,40(r1) <== NOT EXECUTED
ffc21e34: 83 a1 00 2c lwz r29,44(r1) <== NOT EXECUTED
ffc21e38: 83 c1 00 30 lwz r30,48(r1) <== NOT EXECUTED
ffc21e3c: 83 e1 00 34 lwz r31,52(r1) <== NOT EXECUTED
ffc21e40: 38 21 00 38 addi r1,r1,56 <== NOT EXECUTED
ffc21e44: 4e 80 00 20 blr <== NOT EXECUTED
}
if ( FAT_CLUSTER_IS_ODD(cln) )
*ret_val = (*ret_val) >> FAT12_SHIFT;
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
ffc21e48: 54 00 05 3e clrlwi r0,r0,20
ffc21e4c: 90 1a 00 00 stw r0,0(r26)
ffc21e50: 4b ff fe b4 b ffc21d04 <fat_get_fat_cluster+0xd0>
* align problems for some architectures
*/
*ret_val = (*((uint8_t *)(block0->buffer + ofs)));
if ( ofs == (fs_info->vol.bps - 1) )
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
ffc21e54: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc21e58: 38 9b 00 01 addi r4,r27,1 <== NOT EXECUTED
ffc21e5c: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc21e60: 38 c1 00 08 addi r6,r1,8 <== NOT EXECUTED
ffc21e64: 4b ff 64 55 bl ffc182b8 <fat_buf_access> <== NOT EXECUTED
&block0);
if (rc != RC_OK)
ffc21e68: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc21e6c: 40 82 00 24 bne- ffc21e90 <fat_get_fat_cluster+0x25c> <== NOT EXECUTED
return rc;
*ret_val |= (*((uint8_t *)(block0->buffer)))<<8;
ffc21e70: 81 21 00 08 lwz r9,8(r1) <== NOT EXECUTED
ffc21e74: 80 1a 00 00 lwz r0,0(r26) <== NOT EXECUTED
ffc21e78: 81 29 00 24 lwz r9,36(r9) <== NOT EXECUTED
ffc21e7c: 89 29 00 00 lbz r9,0(r9) <== NOT EXECUTED
ffc21e80: 55 29 40 2e rlwinm r9,r9,8,0,23 <== NOT EXECUTED
ffc21e84: 7d 20 03 78 or r0,r9,r0 <== NOT EXECUTED
ffc21e88: 90 1a 00 00 stw r0,0(r26) <== NOT EXECUTED
ffc21e8c: 4b ff ff 58 b ffc21de4 <fat_get_fat_cluster+0x1b0> <== NOT EXECUTED
*ret_val = (*((uint8_t *)(block0->buffer + ofs)));
if ( ofs == (fs_info->vol.bps - 1) )
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
&block0);
if (rc != RC_OK)
ffc21e90: 7c 7c 1b 78 mr r28,r3 <== NOT EXECUTED
ffc21e94: 4b ff fe 70 b ffc21d04 <fat_get_fat_cluster+0xd0> <== NOT EXECUTED
ffc18a94 <fat_get_unique_ino>:
* 0 means FAILED !!!
*
*/
uint32_t
fat_get_unique_ino(rtems_filesystem_mount_table_entry_t *mt_entry)
{
ffc18a94: 94 21 ff e8 stwu r1,-24(r1) <== NOT EXECUTED
ffc18a98: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc18a9c: 90 01 00 1c stw r0,28(r1) <== NOT EXECUTED
ffc18aa0: 93 e1 00 14 stw r31,20(r1) <== NOT EXECUTED
register fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc18aa4: 83 e3 00 34 lwz r31,52(r3) <== NOT EXECUTED
* 0 means FAILED !!!
*
*/
uint32_t
fat_get_unique_ino(rtems_filesystem_mount_table_entry_t *mt_entry)
{
ffc18aa8: 93 a1 00 0c stw r29,12(r1) <== NOT EXECUTED
fs_info->index++;
if (fs_info->index >= fs_info->uino_pool_size)
fs_info->index = 0;
}
if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base))
ffc18aac: 3f a0 0f ff lis r29,4095 <== NOT EXECUTED
ffc18ab0: 63 bd ff ff ori r29,r29,65535 <== NOT EXECUTED
*
*/
uint32_t
fat_get_unique_ino(rtems_filesystem_mount_table_entry_t *mt_entry)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc18ab4: 80 df 00 78 lwz r6,120(r31) <== NOT EXECUTED
* 0 means FAILED !!!
*
*/
uint32_t
fat_get_unique_ino(rtems_filesystem_mount_table_entry_t *mt_entry)
{
ffc18ab8: 93 c1 00 10 stw r30,16(r1) <== NOT EXECUTED
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
{
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
ffc18abc: 3b c0 00 00 li r30,0 <== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
ffc18ac0: 2f 86 00 00 cmpwi cr7,r6,0 <== NOT EXECUTED
ffc18ac4: 41 9e 00 a0 beq- cr7,ffc18b64 <fat_get_unique_ino+0xd0> <== NOT EXECUTED
{
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
ffc18ac8: 81 3f 00 74 lwz r9,116(r31) <== NOT EXECUTED
ffc18acc: 81 7f 00 70 lwz r11,112(r31) <== NOT EXECUTED
ffc18ad0: 55 20 e8 fe rlwinm r0,r9,29,3,31 <== NOT EXECUTED
ffc18ad4: 7d 4b 00 ae lbzx r10,r11,r0 <== NOT EXECUTED
ffc18ad8: 55 28 07 7e clrlwi r8,r9,29 <== NOT EXECUTED
ffc18adc: 7c 0b 02 14 add r0,r11,r0 <== NOT EXECUTED
ffc18ae0: 7d 47 46 30 sraw r7,r10,r8 <== NOT EXECUTED
ffc18ae4: 70 e5 00 01 andi. r5,r7,1 <== NOT EXECUTED
ffc18ae8: 41 82 00 40 beq- ffc18b28 <fat_get_unique_ino+0x94> <== NOT EXECUTED
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
return (fs_info->uino_base + fs_info->index);
}
fs_info->index++;
if (fs_info->index >= fs_info->uino_pool_size)
fs_info->index = 0;
ffc18aec: 7c c9 03 a6 mtctr r6 <== NOT EXECUTED
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
{
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
return (fs_info->uino_base + fs_info->index);
}
fs_info->index++;
ffc18af0: 39 29 00 01 addi r9,r9,1 <== NOT EXECUTED
if (fs_info->index >= fs_info->uino_pool_size)
ffc18af4: 7f 89 30 40 cmplw cr7,r9,r6 <== NOT EXECUTED
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
{
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
return (fs_info->uino_base + fs_info->index);
}
fs_info->index++;
ffc18af8: 91 3f 00 74 stw r9,116(r31) <== NOT EXECUTED
if (fs_info->index >= fs_info->uino_pool_size)
ffc18afc: 41 9c 00 08 blt- cr7,ffc18b04 <fat_get_unique_ino+0x70> <== NOT EXECUTED
fs_info->index = 0;
ffc18b00: 93 df 00 74 stw r30,116(r31) <== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
ffc18b04: 42 40 00 60 bdz- ffc18b64 <fat_get_unique_ino+0xd0> <== NOT EXECUTED
{
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
ffc18b08: 81 3f 00 74 lwz r9,116(r31) <== NOT EXECUTED
ffc18b0c: 55 20 e8 fe rlwinm r0,r9,29,3,31 <== NOT EXECUTED
ffc18b10: 7d 4b 00 ae lbzx r10,r11,r0 <== NOT EXECUTED
ffc18b14: 55 28 07 7e clrlwi r8,r9,29 <== NOT EXECUTED
ffc18b18: 7c 0b 02 14 add r0,r11,r0 <== NOT EXECUTED
ffc18b1c: 7d 47 46 30 sraw r7,r10,r8 <== NOT EXECUTED
ffc18b20: 70 e5 00 01 andi. r5,r7,1 <== NOT EXECUTED
ffc18b24: 40 82 ff cc bne+ ffc18af0 <fat_get_unique_ino+0x5c> <== NOT EXECUTED
{
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
ffc18b28: 39 20 00 01 li r9,1 <== NOT EXECUTED
ffc18b2c: 7d 28 40 30 slw r8,r9,r8 <== NOT EXECUTED
ffc18b30: 7d 0a 53 78 or r10,r8,r10 <== NOT EXECUTED
ffc18b34: 7c 09 03 78 mr r9,r0 <== NOT EXECUTED
ffc18b38: 99 49 00 00 stb r10,0(r9) <== NOT EXECUTED
return (fs_info->uino_base + fs_info->index);
ffc18b3c: 80 1f 00 7c lwz r0,124(r31) <== NOT EXECUTED
ffc18b40: 80 7f 00 74 lwz r3,116(r31) <== NOT EXECUTED
}
else
resrc_unsuff = true;
}
return 0;
}
ffc18b44: 83 a1 00 0c lwz r29,12(r1) <== NOT EXECUTED
for (j = 0; j < fs_info->uino_pool_size; j++)
{
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
{
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
return (fs_info->uino_base + fs_info->index);
ffc18b48: 7c 63 02 14 add r3,r3,r0 <== NOT EXECUTED
}
else
resrc_unsuff = true;
}
return 0;
}
ffc18b4c: 80 01 00 1c lwz r0,28(r1) <== NOT EXECUTED
ffc18b50: 83 c1 00 10 lwz r30,16(r1) <== NOT EXECUTED
ffc18b54: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc18b58: 83 e1 00 14 lwz r31,20(r1) <== NOT EXECUTED
ffc18b5c: 38 21 00 18 addi r1,r1,24 <== NOT EXECUTED
ffc18b60: 4e 80 00 20 blr <== NOT EXECUTED
fs_info->index++;
if (fs_info->index >= fs_info->uino_pool_size)
fs_info->index = 0;
}
if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base))
ffc18b64: 80 1f 00 7c lwz r0,124(r31) <== NOT EXECUTED
ffc18b68: 54 c4 08 3c rlwinm r4,r6,1,0,30 <== NOT EXECUTED
ffc18b6c: 7c 00 e8 50 subf r0,r0,r29 <== NOT EXECUTED
ffc18b70: 7f 84 00 40 cmplw cr7,r4,r0 <== NOT EXECUTED
ffc18b74: 41 9c 00 24 blt- cr7,ffc18b98 <fat_get_unique_ino+0x104><== NOT EXECUTED
}
else
resrc_unsuff = true;
}
return 0;
}
ffc18b78: 80 01 00 1c lwz r0,28(r1) <== NOT EXECUTED
resrc_unsuff = true;
}
else
resrc_unsuff = true;
}
return 0;
ffc18b7c: 38 60 00 00 li r3,0 <== NOT EXECUTED
}
ffc18b80: 83 a1 00 0c lwz r29,12(r1) <== NOT EXECUTED
ffc18b84: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc18b88: 83 c1 00 10 lwz r30,16(r1) <== NOT EXECUTED
ffc18b8c: 83 e1 00 14 lwz r31,20(r1) <== NOT EXECUTED
ffc18b90: 38 21 00 18 addi r1,r1,24 <== NOT EXECUTED
ffc18b94: 4e 80 00 20 blr <== NOT EXECUTED
fs_info->index = 0;
}
if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base))
{
fs_info->uino_pool_size <<= 1;
ffc18b98: 90 9f 00 78 stw r4,120(r31) <== NOT EXECUTED
fs_info->uino = realloc(fs_info->uino, fs_info->uino_pool_size);
ffc18b9c: 80 7f 00 70 lwz r3,112(r31) <== NOT EXECUTED
ffc18ba0: 4b ff 13 61 bl ffc09f00 <realloc> <== NOT EXECUTED
if (fs_info->uino != NULL)
ffc18ba4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
}
if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base))
{
fs_info->uino_pool_size <<= 1;
fs_info->uino = realloc(fs_info->uino, fs_info->uino_pool_size);
ffc18ba8: 90 7f 00 70 stw r3,112(r31) <== NOT EXECUTED
if (fs_info->uino != NULL)
ffc18bac: 41 9e ff cc beq+ cr7,ffc18b78 <fat_get_unique_ino+0xe4> <== NOT EXECUTED
fs_info->index = fs_info->uino_pool_size;
ffc18bb0: 80 df 00 78 lwz r6,120(r31) <== NOT EXECUTED
ffc18bb4: 90 df 00 74 stw r6,116(r31) <== NOT EXECUTED
ffc18bb8: 4b ff ff 08 b ffc18ac0 <fat_get_unique_ino+0x2c> <== NOT EXECUTED
ffc18968 <fat_init_clusters_chain>:
int
fat_init_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start_cln
)
{
ffc18968: 94 21 ff d8 stwu r1,-40(r1)
ffc1896c: 7c 08 02 a6 mflr r0
ffc18970: 90 01 00 2c stw r0,44(r1)
ffc18974: 93 c1 00 20 stw r30,32(r1)
int rc = RC_OK;
ssize_t ret = 0;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc18978: 83 c3 00 34 lwz r30,52(r3)
int
fat_init_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start_cln
)
{
ffc1897c: 93 a1 00 1c stw r29,28(r1)
ffc18980: 7c 7d 1b 78 mr r29,r3
ssize_t ret = 0;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = start_cln;
char *buf;
buf = calloc(fs_info->vol.bpc, sizeof(char));
ffc18984: a0 7e 00 06 lhz r3,6(r30)
int
fat_init_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start_cln
)
{
ffc18988: 93 e1 00 24 stw r31,36(r1)
ffc1898c: 7c 9f 23 78 mr r31,r4
ssize_t ret = 0;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = start_cln;
char *buf;
buf = calloc(fs_info->vol.bpc, sizeof(char));
ffc18990: 38 80 00 01 li r4,1
int
fat_init_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start_cln
)
{
ffc18994: 93 81 00 18 stw r28,24(r1)
int rc = RC_OK;
ssize_t ret = 0;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = start_cln;
ffc18998: 93 e1 00 08 stw r31,8(r1)
char *buf;
buf = calloc(fs_info->vol.bpc, sizeof(char));
ffc1899c: 4b fe f4 95 bl ffc07e30 <calloc>
if ( buf == NULL )
ffc189a0: 7c 7c 1b 79 mr. r28,r3
ffc189a4: 40 a2 00 0c bne+ ffc189b0 <fat_init_clusters_chain+0x48><== ALWAYS TAKEN
ffc189a8: 48 00 00 d8 b ffc18a80 <fat_init_clusters_chain+0x118><== NOT EXECUTED
free(buf);
return -1;
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
if ( rc != RC_OK )
ffc189ac: 83 e1 00 08 lwz r31,8(r1)
buf = calloc(fs_info->vol.bpc, sizeof(char));
if ( buf == NULL )
rtems_set_errno_and_return_minus_one( EIO );
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
ffc189b0: 81 3e 00 0c lwz r9,12(r30)
{
ret = fat_cluster_write(mt_entry, cur_cln, buf);
ffc189b4: 7f e4 fb 78 mr r4,r31
buf = calloc(fs_info->vol.bpc, sizeof(char));
if ( buf == NULL )
rtems_set_errno_and_return_minus_one( EIO );
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
ffc189b8: 80 1e 00 10 lwz r0,16(r30)
{
ret = fat_cluster_write(mt_entry, cur_cln, buf);
ffc189bc: 7f 85 e3 78 mr r5,r28
buf = calloc(fs_info->vol.bpc, sizeof(char));
if ( buf == NULL )
rtems_set_errno_and_return_minus_one( EIO );
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
ffc189c0: 7f ff 48 38 and r31,r31,r9
ffc189c4: 7f 9f 00 40 cmplw cr7,r31,r0
{
ret = fat_cluster_write(mt_entry, cur_cln, buf);
ffc189c8: 7f a3 eb 78 mr r3,r29
buf = calloc(fs_info->vol.bpc, sizeof(char));
if ( buf == NULL )
rtems_set_errno_and_return_minus_one( EIO );
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
ffc189cc: 40 9c 00 54 bge- cr7,ffc18a20 <fat_init_clusters_chain+0xb8>
{
ret = fat_cluster_write(mt_entry, cur_cln, buf);
ffc189d0: 4b ff ff 3d bl ffc1890c <fat_cluster_write>
{
free(buf);
return -1;
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
ffc189d4: 38 a1 00 08 addi r5,r1,8
rtems_set_errno_and_return_minus_one( EIO );
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
ret = fat_cluster_write(mt_entry, cur_cln, buf);
if ( ret == -1 )
ffc189d8: 2f 83 ff ff cmpwi cr7,r3,-1
{
free(buf);
return -1;
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
ffc189dc: 7f a3 eb 78 mr r3,r29
rtems_set_errno_and_return_minus_one( EIO );
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
ret = fat_cluster_write(mt_entry, cur_cln, buf);
if ( ret == -1 )
ffc189e0: 41 9e 00 70 beq- cr7,ffc18a50 <fat_init_clusters_chain+0xe8><== NEVER TAKEN
{
free(buf);
return -1;
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
ffc189e4: 80 81 00 08 lwz r4,8(r1)
ffc189e8: 48 00 92 4d bl ffc21c34 <fat_get_fat_cluster>
if ( rc != RC_OK )
ffc189ec: 7c 7f 1b 79 mr. r31,r3
ffc189f0: 41 82 ff bc beq+ ffc189ac <fat_init_clusters_chain+0x44><== ALWAYS TAKEN
{
free(buf);
ffc189f4: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc189f8: 4b fe fa e9 bl ffc084e0 <free> <== NOT EXECUTED
}
}
free(buf);
return rc;
}
ffc189fc: 80 01 00 2c lwz r0,44(r1) <== NOT EXECUTED
ffc18a00: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc18a04: 83 81 00 18 lwz r28,24(r1) <== NOT EXECUTED
ffc18a08: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc18a0c: 83 a1 00 1c lwz r29,28(r1) <== NOT EXECUTED
ffc18a10: 83 c1 00 20 lwz r30,32(r1) <== NOT EXECUTED
ffc18a14: 83 e1 00 24 lwz r31,36(r1) <== NOT EXECUTED
ffc18a18: 38 21 00 28 addi r1,r1,40 <== NOT EXECUTED
ffc18a1c: 4e 80 00 20 blr <== NOT EXECUTED
free(buf);
return rc;
}
}
free(buf);
ffc18a20: 7f 83 e3 78 mr r3,r28
ffc18a24: 4b fe fa bd bl ffc084e0 <free>
return rc;
}
ffc18a28: 80 01 00 2c lwz r0,44(r1)
return rc;
}
}
free(buf);
return rc;
ffc18a2c: 3b e0 00 00 li r31,0
}
ffc18a30: 83 81 00 18 lwz r28,24(r1)
ffc18a34: 7c 08 03 a6 mtlr r0
ffc18a38: 7f e3 fb 78 mr r3,r31
ffc18a3c: 83 a1 00 1c lwz r29,28(r1)
ffc18a40: 83 c1 00 20 lwz r30,32(r1)
ffc18a44: 83 e1 00 24 lwz r31,36(r1)
ffc18a48: 38 21 00 28 addi r1,r1,40
ffc18a4c: 4e 80 00 20 blr
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
ret = fat_cluster_write(mt_entry, cur_cln, buf);
if ( ret == -1 )
{
free(buf);
ffc18a50: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc18a54: 4b fe fa 8d bl ffc084e0 <free> <== NOT EXECUTED
}
}
free(buf);
return rc;
}
ffc18a58: 80 01 00 2c lwz r0,44(r1) <== NOT EXECUTED
{
ret = fat_cluster_write(mt_entry, cur_cln, buf);
if ( ret == -1 )
{
free(buf);
return -1;
ffc18a5c: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
}
}
free(buf);
return rc;
}
ffc18a60: 83 81 00 18 lwz r28,24(r1) <== NOT EXECUTED
ffc18a64: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc18a68: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc18a6c: 83 a1 00 1c lwz r29,28(r1) <== NOT EXECUTED
ffc18a70: 83 c1 00 20 lwz r30,32(r1) <== NOT EXECUTED
ffc18a74: 83 e1 00 24 lwz r31,36(r1) <== NOT EXECUTED
ffc18a78: 38 21 00 28 addi r1,r1,40 <== NOT EXECUTED
ffc18a7c: 4e 80 00 20 blr <== NOT EXECUTED
uint32_t cur_cln = start_cln;
char *buf;
buf = calloc(fs_info->vol.bpc, sizeof(char));
if ( buf == NULL )
rtems_set_errno_and_return_minus_one( EIO );
ffc18a80: 48 00 b7 91 bl ffc24210 <__errno> <== NOT EXECUTED
ffc18a84: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc18a88: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc18a8c: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc18a90: 4b ff ff 6c b ffc189fc <fat_init_clusters_chain+0x94><== NOT EXECUTED
ffc18ddc <fat_init_volume_info>:
* RC_OK on success, or -1 if error occured
* and errno set appropriately
*/
int
fat_init_volume_info(rtems_filesystem_mount_table_entry_t *mt_entry)
{
ffc18ddc: 94 21 ff 20 stwu r1,-224(r1)
ffc18de0: 7c 08 02 a6 mflr r0
ffc18de4: 90 01 00 e4 stw r0,228(r1)
ssize_t ret = 0;
struct stat stat_buf;
int i = 0;
rtems_bdbuf_buffer *block = NULL;
rc = stat(mt_entry->dev, &stat_buf);
ffc18de8: 38 81 00 18 addi r4,r1,24
char boot_rec[FAT_MAX_BPB_SIZE];
char fs_info_sector[FAT_USEFUL_INFO_SIZE];
ssize_t ret = 0;
struct stat stat_buf;
int i = 0;
rtems_bdbuf_buffer *block = NULL;
ffc18dec: 38 00 00 00 li r0,0
* RC_OK on success, or -1 if error occured
* and errno set appropriately
*/
int
fat_init_volume_info(rtems_filesystem_mount_table_entry_t *mt_entry)
{
ffc18df0: 93 c1 00 d8 stw r30,216(r1)
ffc18df4: 7c 7e 1b 78 mr r30,r3
ssize_t ret = 0;
struct stat stat_buf;
int i = 0;
rtems_bdbuf_buffer *block = NULL;
rc = stat(mt_entry->dev, &stat_buf);
ffc18df8: 80 63 00 70 lwz r3,112(r3)
* RC_OK on success, or -1 if error occured
* and errno set appropriately
*/
int
fat_init_volume_info(rtems_filesystem_mount_table_entry_t *mt_entry)
{
ffc18dfc: 93 a1 00 d4 stw r29,212(r1)
ffc18e00: 93 e1 00 dc stw r31,220(r1)
ffc18e04: 91 c1 00 98 stw r14,152(r1)
ffc18e08: 91 e1 00 9c stw r15,156(r1)
ffc18e0c: 92 01 00 a0 stw r16,160(r1)
ffc18e10: 92 21 00 a4 stw r17,164(r1)
ffc18e14: 92 41 00 a8 stw r18,168(r1)
ffc18e18: 92 61 00 ac stw r19,172(r1)
ffc18e1c: 92 81 00 b0 stw r20,176(r1)
ffc18e20: 92 a1 00 b4 stw r21,180(r1)
ffc18e24: 92 c1 00 b8 stw r22,184(r1)
ffc18e28: 92 e1 00 bc stw r23,188(r1)
ffc18e2c: 93 01 00 c0 stw r24,192(r1)
ffc18e30: 93 21 00 c4 stw r25,196(r1)
ffc18e34: 93 41 00 c8 stw r26,200(r1)
ffc18e38: 93 61 00 cc stw r27,204(r1)
ffc18e3c: 93 81 00 d0 stw r28,208(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc18e40: 83 fe 00 34 lwz r31,52(r30)
char boot_rec[FAT_MAX_BPB_SIZE];
char fs_info_sector[FAT_USEFUL_INFO_SIZE];
ssize_t ret = 0;
struct stat stat_buf;
int i = 0;
rtems_bdbuf_buffer *block = NULL;
ffc18e44: 90 01 00 08 stw r0,8(r1)
rc = stat(mt_entry->dev, &stat_buf);
ffc18e48: 4b ff 14 25 bl ffc0a26c <stat>
if (rc == -1)
ffc18e4c: 2f 83 ff ff cmpwi cr7,r3,-1
ssize_t ret = 0;
struct stat stat_buf;
int i = 0;
rtems_bdbuf_buffer *block = NULL;
rc = stat(mt_entry->dev, &stat_buf);
ffc18e50: 7c 7d 1b 78 mr r29,r3
if (rc == -1)
ffc18e54: 41 9e 03 d8 beq- cr7,ffc1922c <fat_init_volume_info+0x450><== NEVER TAKEN
return rc;
/* Must be a block device. */
if (!S_ISBLK(stat_buf.st_mode))
ffc18e58: 80 01 00 24 lwz r0,36(r1)
ffc18e5c: 54 00 04 26 rlwinm r0,r0,0,16,19
ffc18e60: 2f 80 60 00 cmpwi cr7,r0,24576
ffc18e64: 40 9e 06 34 bne- cr7,ffc19498 <fat_init_volume_info+0x6bc><== NEVER TAKEN
rtems_set_errno_and_return_minus_one(ENOTTY);
/* check that device is registred as block device and lock it */
vol->dd = rtems_disk_obtain(stat_buf.st_rdev);
ffc18e68: 80 61 00 30 lwz r3,48(r1)
ffc18e6c: 80 81 00 34 lwz r4,52(r1)
ffc18e70: 4b fe e1 a1 bl ffc07010 <rtems_disk_obtain>
if (vol->dd == NULL)
ffc18e74: 2f 83 00 00 cmpwi cr7,r3,0
/* Must be a block device. */
if (!S_ISBLK(stat_buf.st_mode))
rtems_set_errno_and_return_minus_one(ENOTTY);
/* check that device is registred as block device and lock it */
vol->dd = rtems_disk_obtain(stat_buf.st_rdev);
ffc18e78: 90 7f 00 60 stw r3,96(r31)
if (vol->dd == NULL)
ffc18e7c: 41 9e 06 90 beq- cr7,ffc1950c <fat_init_volume_info+0x730><== NEVER TAKEN
rtems_set_errno_and_return_minus_one(EIO);
vol->dev = stat_buf.st_rdev;
ffc18e80: 80 61 00 30 lwz r3,48(r1)
/* Read boot record */
/* FIXME: Asserts FAT_MAX_BPB_SIZE < bdbuf block size */
sc = rtems_bdbuf_read( vol->dev, 0, &block);
ffc18e84: 38 a0 00 00 li r5,0
/* check that device is registred as block device and lock it */
vol->dd = rtems_disk_obtain(stat_buf.st_rdev);
if (vol->dd == NULL)
rtems_set_errno_and_return_minus_one(EIO);
vol->dev = stat_buf.st_rdev;
ffc18e88: 80 81 00 34 lwz r4,52(r1)
/* Read boot record */
/* FIXME: Asserts FAT_MAX_BPB_SIZE < bdbuf block size */
sc = rtems_bdbuf_read( vol->dev, 0, &block);
ffc18e8c: 38 c1 00 08 addi r6,r1,8
/* check that device is registred as block device and lock it */
vol->dd = rtems_disk_obtain(stat_buf.st_rdev);
if (vol->dd == NULL)
rtems_set_errno_and_return_minus_one(EIO);
vol->dev = stat_buf.st_rdev;
ffc18e90: 90 7f 00 58 stw r3,88(r31)
ffc18e94: 90 9f 00 5c stw r4,92(r31)
/* Read boot record */
/* FIXME: Asserts FAT_MAX_BPB_SIZE < bdbuf block size */
sc = rtems_bdbuf_read( vol->dev, 0, &block);
ffc18e98: 4b ff d2 15 bl ffc160ac <rtems_bdbuf_read>
if (sc != RTEMS_SUCCESSFUL)
ffc18e9c: 2f 83 00 00 cmpwi cr7,r3,0
ffc18ea0: 40 9e 06 64 bne- cr7,ffc19504 <fat_init_volume_info+0x728><== NEVER TAKEN
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EIO);
}
memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);
ffc18ea4: 80 61 00 08 lwz r3,8(r1)
ffc18ea8: 81 23 00 24 lwz r9,36(r3)
ffc18eac: 88 09 00 20 lbz r0,32(r9)
ffc18eb0: 89 49 00 21 lbz r10,33(r9)
ffc18eb4: 89 69 00 22 lbz r11,34(r9)
ffc18eb8: 90 01 00 68 stw r0,104(r1)
ffc18ebc: 91 41 00 6c stw r10,108(r1)
ffc18ec0: 88 09 00 23 lbz r0,35(r9)
ffc18ec4: 89 49 00 28 lbz r10,40(r9)
ffc18ec8: 91 61 00 70 stw r11,112(r1)
ffc18ecc: 90 01 00 74 stw r0,116(r1)
ffc18ed0: 89 69 00 2c lbz r11,44(r9)
ffc18ed4: 88 09 00 2d lbz r0,45(r9)
ffc18ed8: 91 41 00 78 stw r10,120(r1)
ffc18edc: 89 49 00 2e lbz r10,46(r9)
ffc18ee0: 8b 69 00 0b lbz r27,11(r9)
ffc18ee4: 8b 49 00 0c lbz r26,12(r9)
ffc18ee8: 8b a9 00 0d lbz r29,13(r9)
ffc18eec: 8b 29 00 0e lbz r25,14(r9)
ffc18ef0: 8b 09 00 0f lbz r24,15(r9)
ffc18ef4: 8b 89 00 10 lbz r28,16(r9)
ffc18ef8: 8a e9 00 11 lbz r23,17(r9)
ffc18efc: 8a c9 00 12 lbz r22,18(r9)
ffc18f00: 8a a9 00 13 lbz r21,19(r9)
ffc18f04: 8a 89 00 14 lbz r20,20(r9)
ffc18f08: 8a 69 00 16 lbz r19,22(r9)
ffc18f0c: 8a 49 00 17 lbz r18,23(r9)
ffc18f10: 89 e9 00 24 lbz r15,36(r9)
ffc18f14: 89 c9 00 25 lbz r14,37(r9)
ffc18f18: 8a 29 00 26 lbz r17,38(r9)
ffc18f1c: 8a 09 00 27 lbz r16,39(r9)
ffc18f20: 91 61 00 88 stw r11,136(r1)
ffc18f24: 90 01 00 8c stw r0,140(r1)
ffc18f28: 91 41 00 90 stw r10,144(r1)
ffc18f2c: 89 69 00 2f lbz r11,47(r9)
ffc18f30: 88 09 00 30 lbz r0,48(r9)
ffc18f34: 89 29 00 31 lbz r9,49(r9)
ffc18f38: 91 61 00 84 stw r11,132(r1)
ffc18f3c: 90 01 00 7c stw r0,124(r1)
ffc18f40: 91 21 00 80 stw r9,128(r1)
sc = rtems_bdbuf_release( block);
ffc18f44: 4b ff d4 c5 bl ffc16408 <rtems_bdbuf_release>
if (sc != RTEMS_SUCCESSFUL)
ffc18f48: 2c 03 00 00 cmpwi r3,0
ffc18f4c: 40 82 05 d4 bne- ffc19520 <fat_init_volume_info+0x744> <== NEVER TAKEN
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EIO );
}
/* Evaluate boot record */
vol->bps = FAT_GET_BR_BYTES_PER_SECTOR(boot_rec);
ffc18f50: 57 5a 40 2e rlwinm r26,r26,8,0,23
ffc18f54: 7f 5b db 78 or r27,r26,r27
if ( (vol->bps != 512) &&
ffc18f58: 2f 9b 02 00 cmpwi cr7,r27,512
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EIO );
}
/* Evaluate boot record */
vol->bps = FAT_GET_BR_BYTES_PER_SECTOR(boot_rec);
ffc18f5c: b3 7f 00 00 sth r27,0(r31)
if ( (vol->bps != 512) &&
ffc18f60: 41 9e 05 00 beq- cr7,ffc19460 <fat_init_volume_info+0x684><== ALWAYS TAKEN
ffc18f64: 2f 9b 04 00 cmpwi cr7,r27,1024 <== NOT EXECUTED
ffc18f68: 41 9e 00 14 beq- cr7,ffc18f7c <fat_init_volume_info+0x1a0><== NOT EXECUTED
(vol->bps != 1024) &&
ffc18f6c: 2f 9b 08 00 cmpwi cr7,r27,2048 <== NOT EXECUTED
ffc18f70: 41 9e 00 0c beq- cr7,ffc18f7c <fat_init_volume_info+0x1a0><== NOT EXECUTED
(vol->bps != 2048) &&
ffc18f74: 2f 9b 10 00 cmpwi cr7,r27,4096 <== NOT EXECUTED
ffc18f78: 40 9e 05 3c bne- cr7,ffc194b4 <fat_init_volume_info+0x6d8><== NOT EXECUTED
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
ffc18f7c: 57 60 ba 7e rlwinm r0,r27,23,9,31 <== NOT EXECUTED
ffc18f80: 39 20 00 01 li r9,1 <== NOT EXECUTED
ffc18f84: 48 00 00 08 b ffc18f8c <fat_init_volume_info+0x1b0> <== NOT EXECUTED
ffc18f88: 7d 69 5b 78 mr r9,r11 <== NOT EXECUTED
i >>= 1, vol->sec_mul++);
ffc18f8c: 7c 00 0e 70 srawi r0,r0,1 <== NOT EXECUTED
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
ffc18f90: 70 0a 00 01 andi. r10,r0,1 <== NOT EXECUTED
i >>= 1, vol->sec_mul++);
ffc18f94: 39 69 00 01 addi r11,r9,1 <== NOT EXECUTED
ffc18f98: 55 6b 06 3e clrlwi r11,r11,24 <== NOT EXECUTED
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
ffc18f9c: 41 82 ff ec beq+ ffc18f88 <fat_init_volume_info+0x1ac> <== NOT EXECUTED
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
ffc18fa0: 73 6b 00 01 andi. r11,r27,1 <== NOT EXECUTED
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
ffc18fa4: 99 3f 00 03 stb r9,3(r31) <== NOT EXECUTED
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
ffc18fa8: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc18fac: 98 1f 00 02 stb r0,2(r31) <== NOT EXECUTED
ffc18fb0: 40 82 00 2c bne- ffc18fdc <fat_init_volume_info+0x200> <== NOT EXECUTED
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
ffc18fb4: 7f 60 db 78 mr r0,r27
ffc18fb8: 39 20 00 01 li r9,1
ffc18fbc: 48 00 00 08 b ffc18fc4 <fat_init_volume_info+0x1e8>
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
ffc18fc0: 7d 69 5b 78 mr r9,r11
i >>= 1, vol->sec_log2++);
ffc18fc4: 7c 00 0e 70 srawi r0,r0,1
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
ffc18fc8: 70 0a 00 01 andi. r10,r0,1
i >>= 1, vol->sec_log2++);
ffc18fcc: 39 69 00 01 addi r11,r9,1
ffc18fd0: 55 6b 06 3e clrlwi r11,r11,24
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
ffc18fd4: 41 82 ff ec beq+ ffc18fc0 <fat_init_volume_info+0x1e4>
ffc18fd8: 99 3f 00 02 stb r9,2(r31)
vol->spc = FAT_GET_BR_SECTORS_PER_CLUSTER(boot_rec);
/*
* "sectors per cluster" of zero is invalid
* (and would hang the following loop)
*/
if (vol->spc == 0)
ffc18fdc: 2f 9d 00 00 cmpwi cr7,r29,0
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
i >>= 1, vol->sec_log2++);
vol->spc = FAT_GET_BR_SECTORS_PER_CLUSTER(boot_rec);
ffc18fe0: 9b bf 00 04 stb r29,4(r31)
/*
* "sectors per cluster" of zero is invalid
* (and would hang the following loop)
*/
if (vol->spc == 0)
ffc18fe4: 41 9e 04 d0 beq- cr7,ffc194b4 <fat_init_volume_info+0x6d8><== NEVER TAKEN
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
ffc18fe8: 73 ab 00 01 andi. r11,r29,1
ffc18fec: 38 00 00 00 li r0,0
ffc18ff0: 98 1f 00 05 stb r0,5(r31)
ffc18ff4: 7f a9 eb 78 mr r9,r29
ffc18ff8: 39 60 00 00 li r11,0
ffc18ffc: 40 82 00 28 bne- ffc19024 <fat_init_volume_info+0x248> <== NEVER TAKEN
ffc19000: 39 60 00 01 li r11,1
ffc19004: 48 00 00 08 b ffc1900c <fat_init_volume_info+0x230>
ffc19008: 7c 0b 03 78 mr r11,r0 <== NOT EXECUTED
i >>= 1, vol->spc_log2++);
ffc1900c: 7d 29 0e 70 srawi r9,r9,1
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
ffc19010: 71 20 00 01 andi. r0,r9,1
i >>= 1, vol->spc_log2++);
ffc19014: 38 0b 00 01 addi r0,r11,1
ffc19018: 54 00 06 3e clrlwi r0,r0,24
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
ffc1901c: 41 82 ff ec beq+ ffc19008 <fat_init_volume_info+0x22c> <== NEVER TAKEN
ffc19020: 99 7f 00 05 stb r11,5(r31)
i >>= 1, vol->spc_log2++);
/*
* "bytes per cluster" value greater than 32K is invalid
*/
if ((vol->bpc = vol->bps << vol->spc_log2) > MS_BYTES_PER_CLUSTER_LIMIT)
ffc19024: 7f 6b 58 30 slw r11,r27,r11
ffc19028: 55 60 04 3e clrlwi r0,r11,16
ffc1902c: 2b 80 80 00 cmplwi cr7,r0,32768
ffc19030: b0 1f 00 06 sth r0,6(r31)
ffc19034: 41 9d 04 80 bgt- cr7,ffc194b4 <fat_init_volume_info+0x6d8><== NEVER TAKEN
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
ffc19038: 70 09 00 01 andi. r9,r0,1
ffc1903c: 39 20 00 00 li r9,0
ffc19040: 99 3f 00 08 stb r9,8(r31)
ffc19044: 40 82 00 28 bne- ffc1906c <fat_init_volume_info+0x290> <== NEVER TAKEN
ffc19048: 39 20 00 01 li r9,1
ffc1904c: 48 00 00 08 b ffc19054 <fat_init_volume_info+0x278>
ffc19050: 7d 69 5b 78 mr r9,r11
i >>= 1, vol->bpc_log2++);
ffc19054: 7c 00 0e 70 srawi r0,r0,1
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
ffc19058: 70 0a 00 01 andi. r10,r0,1
i >>= 1, vol->bpc_log2++);
ffc1905c: 39 69 00 01 addi r11,r9,1
ffc19060: 55 6b 06 3e clrlwi r11,r11,24
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
ffc19064: 41 82 ff ec beq+ ffc19050 <fat_init_volume_info+0x274>
ffc19068: 99 3f 00 08 stb r9,8(r31)
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
ffc1906c: 56 d6 40 2e rlwinm r22,r22,8,0,23
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
ffc19070: 9b 9f 00 09 stb r28,9(r31)
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
ffc19074: 7e d7 bb 78 or r23,r22,r23
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
ffc19078: 38 1b ff ff addi r0,r27,-1
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
ffc1907c: b2 ff 00 20 sth r23,32(r31)
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
ffc19080: 56 e9 28 34 rlwinm r9,r23,5,0,26
ffc19084: 7c 09 02 14 add r0,r9,r0
ffc19088: 7f 60 db d6 divw r27,r0,r27
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
ffc1908c: 88 1f 00 02 lbz r0,2(r31)
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
ffc19090: 56 52 40 2e rlwinm r18,r18,8,0,23
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
ffc19094: 93 7f 00 24 stw r27,36(r31)
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
ffc19098: 7e 53 9b 78 or r19,r18,r19
ffc1909c: 7e 73 07 35 extsh. r19,r19
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
ffc190a0: 57 18 40 2e rlwinm r24,r24,8,0,23
ffc190a4: 7f 19 cb 78 or r25,r24,r25
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
ffc190a8: 7f 60 00 30 slw r0,r27,r0
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
ffc190ac: b3 3f 00 14 sth r25,20(r31)
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
ffc190b0: 90 1f 00 28 stw r0,40(r31)
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
ffc190b4: 41 82 03 8c beq- ffc19440 <fat_init_volume_info+0x664> <== NEVER TAKEN
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
ffc190b8: 56 73 04 3e clrlwi r19,r19,16
ffc190bc: 92 7f 00 18 stw r19,24(r31)
vol->rdir_secs;
/* for FAT12/16 root dir starts at(sector) */
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
ffc190c0: 56 94 40 2e rlwinm r20,r20,8,0,23
ffc190c4: 7e 95 ab 78 or r21,r20,r21
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
else
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
ffc190c8: 7f 93 e1 d6 mullw r28,r19,r28
vol->rdir_secs;
/* for FAT12/16 root dir starts at(sector) */
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
ffc190cc: 7e b5 07 35 extsh. r21,r21
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
else
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
ffc190d0: 7f 9c ca 14 add r28,r28,r25
ffc190d4: 7f 7c da 14 add r27,r28,r27
vol->rdir_secs;
/* for FAT12/16 root dir starts at(sector) */
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
ffc190d8: 93 9f 00 1c stw r28,28(r31)
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
else
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
ffc190dc: 93 7f 00 30 stw r27,48(r31)
vol->rdir_secs;
/* for FAT12/16 root dir starts at(sector) */
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
ffc190e0: 41 82 03 30 beq- ffc19410 <fat_init_volume_info+0x634> <== NEVER TAKEN
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);
ffc190e4: 56 b5 04 3e clrlwi r21,r21,16
ffc190e8: 92 bf 00 2c stw r21,44(r31)
else
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
data_secs = vol->tot_secs - vol->data_fsec;
ffc190ec: 7f 7b a8 50 subf r27,r27,r21
vol->data_cls = data_secs / vol->spc;
ffc190f0: 7f bb eb 96 divwu r29,r27,r29
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
ffc190f4: 2b 9d 0f f4 cmplwi cr7,r29,4084
else
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
data_secs = vol->tot_secs - vol->data_fsec;
vol->data_cls = data_secs / vol->spc;
ffc190f8: 93 bf 00 34 stw r29,52(r31)
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
ffc190fc: 41 9d 01 8c bgt- cr7,ffc19288 <fat_init_volume_info+0x4ac><== NEVER TAKEN
{
vol->type = FAT_FAT12;
ffc19100: 38 00 00 01 li r0,1
ffc19104: 98 1f 00 0a stb r0,10(r31)
vol->mask = FAT_FAT12_MASK;
ffc19108: 38 00 0f ff li r0,4095
ffc1910c: 90 1f 00 0c stw r0,12(r31)
vol->eoc_val = FAT_FAT12_EOC;
ffc19110: 38 00 0f f8 li r0,4088
ffc19114: 90 1f 00 10 stw r0,16(r31)
}
}
}
else
{
vol->rdir_cl = 0;
ffc19118: 38 00 00 00 li r0,0
vol->mirror = 0;
vol->afat = 0;
vol->free_cls = 0xFFFFFFFF;
ffc1911c: 39 20 ff ff li r9,-1
}
}
}
else
{
vol->rdir_cl = 0;
ffc19120: 90 1f 00 38 stw r0,56(r31)
vol->mirror = 0;
ffc19124: 98 1f 00 48 stb r0,72(r31)
vol->afat = 0;
ffc19128: 98 1f 00 50 stb r0,80(r31)
vol->free_cls = 0xFFFFFFFF;
ffc1912c: 91 3f 00 40 stw r9,64(r31)
vol->next_cl = 0xFFFFFFFF;
ffc19130: 91 3f 00 44 stw r9,68(r31)
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
ffc19134: 80 7e 00 34 lwz r3,52(r30)
ffc19138: 4b ff f3 c9 bl ffc18500 <fat_buf_release>
vol->next_cl = 0xFFFFFFFF;
}
_fat_block_release(mt_entry);
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
ffc1913c: 89 7f 00 50 lbz r11,80(r31)
ffc19140: 80 1f 00 18 lwz r0,24(r31)
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
ffc19144: 38 60 00 02 li r3,2
vol->next_cl = 0xFFFFFFFF;
}
_fat_block_release(mt_entry);
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
ffc19148: a1 3f 00 14 lhz r9,20(r31)
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
ffc1914c: 38 80 00 0c li r4,12
vol->next_cl = 0xFFFFFFFF;
}
_fat_block_release(mt_entry);
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
ffc19150: 7c 0b 01 d6 mullw r0,r11,r0
ffc19154: 7c 00 4a 14 add r0,r0,r9
ffc19158: 90 1f 00 4c stw r0,76(r31)
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
ffc1915c: 4b fe ec d5 bl ffc07e30 <calloc>
if ( fs_info->vhash == NULL )
ffc19160: 2f 83 00 00 cmpwi cr7,r3,0
_fat_block_release(mt_entry);
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
ffc19164: 90 7f 00 68 stw r3,104(r31)
ffc19168: 7c 69 1b 78 mr r9,r3
if ( fs_info->vhash == NULL )
ffc1916c: 41 9e 04 10 beq- cr7,ffc1957c <fat_init_volume_info+0x7a0><== NEVER TAKEN
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 );
ffc19170: 39 43 00 04 addi r10,r3,4
head->next = tail;
head->previous = NULL;
tail->previous = head;
ffc19174: 91 29 00 08 stw r9,8(r9)
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 );
ffc19178: 38 03 00 0c addi r0,r3,12
ffc1917c: 39 63 00 10 addi r11,r3,16
head->next = tail;
ffc19180: 91 49 00 00 stw r10,0(r9)
head->previous = NULL;
ffc19184: 3b c0 00 00 li r30,0
ffc19188: 93 c9 00 04 stw r30,4(r9)
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->vhash + i);
fs_info->rhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
ffc1918c: 38 60 00 02 li r3,2
ffc19190: 38 80 00 0c li r4,12
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc19194: 91 69 00 0c stw r11,12(r9)
head->previous = NULL;
ffc19198: 93 c9 00 10 stw r30,16(r9)
tail->previous = head;
ffc1919c: 90 09 00 14 stw r0,20(r9)
ffc191a0: 4b fe ec 91 bl ffc07e30 <calloc>
if ( fs_info->rhash == NULL )
ffc191a4: 2f 83 00 00 cmpwi cr7,r3,0
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->vhash + i);
fs_info->rhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
ffc191a8: 90 7f 00 6c stw r3,108(r31)
ffc191ac: 7c 69 1b 78 mr r9,r3
if ( fs_info->rhash == NULL )
ffc191b0: 41 9e 03 bc beq- cr7,ffc1956c <fat_init_volume_info+0x790><== NEVER TAKEN
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 );
ffc191b4: 39 43 00 04 addi r10,r3,4
head->next = tail;
head->previous = NULL;
ffc191b8: 93 c3 00 04 stw r30,4(r3)
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 );
ffc191bc: 38 03 00 0c addi r0,r3,12
ffc191c0: 39 63 00 10 addi r11,r3,16
head->next = tail;
ffc191c4: 91 43 00 00 stw r10,0(r3)
rtems_chain_initialize_empty(fs_info->rhash + i);
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
ffc191c8: 38 80 00 01 li r4,1
ffc191cc: 91 69 00 0c stw r11,12(r9)
rtems_set_errno_and_return_minus_one( ENOMEM );
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->rhash + i);
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
ffc191d0: 39 60 01 00 li r11,256
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
ffc191d4: 38 60 01 00 li r3,256
head->previous = NULL;
tail->previous = head;
ffc191d8: 91 29 00 08 stw r9,8(r9)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
ffc191dc: 93 c9 00 10 stw r30,16(r9)
tail->previous = head;
ffc191e0: 90 09 00 14 stw r0,20(r9)
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->rhash + i);
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
ffc191e4: 81 3f 00 2c lwz r9,44(r31)
ffc191e8: 88 1f 00 03 lbz r0,3(r31)
rtems_set_errno_and_return_minus_one( ENOMEM );
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->rhash + i);
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
ffc191ec: 91 7f 00 78 stw r11,120(r31)
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
ffc191f0: 7d 20 00 30 slw r0,r9,r0
ffc191f4: 54 00 20 36 rlwinm r0,r0,4,0,27
fs_info->index = 0;
ffc191f8: 93 df 00 74 stw r30,116(r31)
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->rhash + i);
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
ffc191fc: 90 1f 00 7c stw r0,124(r31)
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
ffc19200: 4b fe ec 31 bl ffc07e30 <calloc>
if ( fs_info->uino == NULL )
ffc19204: 2f 83 00 00 cmpwi cr7,r3,0
rtems_chain_initialize_empty(fs_info->rhash + i);
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
ffc19208: 90 7f 00 70 stw r3,112(r31)
if ( fs_info->uino == NULL )
ffc1920c: 41 9e 03 30 beq- cr7,ffc1953c <fat_init_volume_info+0x760><== NEVER TAKEN
rtems_disk_release(vol->dd);
free(fs_info->vhash);
free(fs_info->rhash);
rtems_set_errno_and_return_minus_one( ENOMEM );
}
fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));
ffc19210: a0 7f 00 00 lhz r3,0(r31)
ffc19214: 38 80 00 01 li r4,1
free(fs_info->rhash);
free(fs_info->uino);
rtems_set_errno_and_return_minus_one( ENOMEM );
}
return RC_OK;
ffc19218: 3b a0 00 00 li r29,0
rtems_disk_release(vol->dd);
free(fs_info->vhash);
free(fs_info->rhash);
rtems_set_errno_and_return_minus_one( ENOMEM );
}
fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));
ffc1921c: 4b fe ec 15 bl ffc07e30 <calloc>
if (fs_info->sec_buf == NULL)
ffc19220: 2f 83 00 00 cmpwi cr7,r3,0
rtems_disk_release(vol->dd);
free(fs_info->vhash);
free(fs_info->rhash);
rtems_set_errno_and_return_minus_one( ENOMEM );
}
fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));
ffc19224: 90 7f 00 8c stw r3,140(r31)
if (fs_info->sec_buf == NULL)
ffc19228: 41 9e 02 a8 beq- cr7,ffc194d0 <fat_init_volume_info+0x6f4><== NEVER TAKEN
free(fs_info->uino);
rtems_set_errno_and_return_minus_one( ENOMEM );
}
return RC_OK;
}
ffc1922c: 80 01 00 e4 lwz r0,228(r1)
ffc19230: 7f a3 eb 78 mr r3,r29
ffc19234: 81 c1 00 98 lwz r14,152(r1)
ffc19238: 7c 08 03 a6 mtlr r0
ffc1923c: 81 e1 00 9c lwz r15,156(r1)
ffc19240: 82 01 00 a0 lwz r16,160(r1)
ffc19244: 82 21 00 a4 lwz r17,164(r1)
ffc19248: 82 41 00 a8 lwz r18,168(r1)
ffc1924c: 82 61 00 ac lwz r19,172(r1)
ffc19250: 82 81 00 b0 lwz r20,176(r1)
ffc19254: 82 a1 00 b4 lwz r21,180(r1)
ffc19258: 82 c1 00 b8 lwz r22,184(r1)
ffc1925c: 82 e1 00 bc lwz r23,188(r1)
ffc19260: 83 01 00 c0 lwz r24,192(r1)
ffc19264: 83 21 00 c4 lwz r25,196(r1)
ffc19268: 83 41 00 c8 lwz r26,200(r1)
ffc1926c: 83 61 00 cc lwz r27,204(r1)
ffc19270: 83 81 00 d0 lwz r28,208(r1)
ffc19274: 83 a1 00 d4 lwz r29,212(r1)
ffc19278: 83 c1 00 d8 lwz r30,216(r1)
ffc1927c: 83 e1 00 dc lwz r31,220(r1)
ffc19280: 38 21 00 e0 addi r1,r1,224
ffc19284: 4e 80 00 20 blr
vol->mask = FAT_FAT12_MASK;
vol->eoc_val = FAT_FAT12_EOC;
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
ffc19288: 2b 9d ff f4 cmplwi cr7,r29,65524 <== NOT EXECUTED
ffc1928c: 40 9d 01 e0 ble- cr7,ffc1946c <fat_init_volume_info+0x690><== NOT EXECUTED
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
ffc19290: 81 41 00 8c lwz r10,140(r1) <== NOT EXECUTED
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
ffc19294: 81 21 00 78 lwz r9,120(r1) <== NOT EXECUTED
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
ffc19298: 55 4b 40 2e rlwinm r11,r10,8,0,23 <== NOT EXECUTED
ffc1929c: 81 41 00 90 lwz r10,144(r1) <== NOT EXECUTED
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
ffc192a0: 55 20 00 30 rlwinm r0,r9,0,0,24 <== NOT EXECUTED
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
ffc192a4: 55 49 80 1e rlwinm r9,r10,16,0,15 <== NOT EXECUTED
ffc192a8: 81 41 00 84 lwz r10,132(r1) <== NOT EXECUTED
ffc192ac: 7d 6b 4b 78 or r11,r11,r9 <== NOT EXECUTED
ffc192b0: 81 21 00 88 lwz r9,136(r1) <== NOT EXECUTED
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
ffc192b4: 54 00 06 3e clrlwi r0,r0,24 <== NOT EXECUTED
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
ffc192b8: 7d 6b 4b 78 or r11,r11,r9 <== NOT EXECUTED
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
ffc192bc: 98 1f 00 48 stb r0,72(r31) <== NOT EXECUTED
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
ffc192c0: 55 49 c0 0e rlwinm r9,r10,24,0,7 <== NOT EXECUTED
ffc192c4: 7d 69 4b 78 or r9,r11,r9 <== NOT EXECUTED
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
if (vol->mirror)
ffc192c8: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
ffc192cc: 91 3f 00 38 stw r9,56(r31) <== NOT EXECUTED
vol->mask = FAT_FAT16_MASK;
vol->eoc_val = FAT_FAT16_EOC;
}
else
{
vol->type = FAT_FAT32;
ffc192d0: 39 60 00 04 li r11,4 <== NOT EXECUTED
ffc192d4: 99 7f 00 0a stb r11,10(r31) <== NOT EXECUTED
vol->mask = FAT_FAT32_MASK;
ffc192d8: 3d 60 0f ff lis r11,4095 <== NOT EXECUTED
ffc192dc: 61 6b ff ff ori r11,r11,65535 <== NOT EXECUTED
ffc192e0: 91 7f 00 0c stw r11,12(r31) <== NOT EXECUTED
vol->eoc_val = FAT_FAT32_EOC;
ffc192e4: 3d 60 0f ff lis r11,4095 <== NOT EXECUTED
ffc192e8: 61 6b ff f8 ori r11,r11,65528 <== NOT EXECUTED
ffc192ec: 91 7f 00 10 stw r11,16(r31) <== NOT EXECUTED
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
if (vol->mirror)
ffc192f0: 41 9e 01 a0 beq- cr7,ffc19490 <fat_init_volume_info+0x6b4><== NOT EXECUTED
vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
ffc192f4: 81 61 00 78 lwz r11,120(r1) <== NOT EXECUTED
ffc192f8: 55 60 07 3e clrlwi r0,r11,28 <== NOT EXECUTED
ffc192fc: 98 1f 00 50 stb r0,80(r31) <== NOT EXECUTED
else
vol->afat = 0;
vol->info_sec = FAT_GET_BR_FAT32_FS_INFO_SECTOR(boot_rec);
ffc19300: 80 01 00 80 lwz r0,128(r1) <== NOT EXECUTED
ffc19304: 81 21 00 7c lwz r9,124(r1) <== NOT EXECUTED
ffc19308: 54 04 40 2e rlwinm r4,r0,8,0,23 <== NOT EXECUTED
ffc1930c: 7c 84 4b 78 or r4,r4,r9 <== NOT EXECUTED
if( vol->info_sec == 0 )
ffc19310: 2f 84 00 00 cmpwi cr7,r4,0 <== NOT EXECUTED
if (vol->mirror)
vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
else
vol->afat = 0;
vol->info_sec = FAT_GET_BR_FAT32_FS_INFO_SECTOR(boot_rec);
ffc19314: b0 9f 00 3c sth r4,60(r31) <== NOT EXECUTED
if( vol->info_sec == 0 )
ffc19318: 41 9e 01 9c beq- cr7,ffc194b4 <fat_init_volume_info+0x6d8><== NOT EXECUTED
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
else
{
ret = _fat_block_read(mt_entry, vol->info_sec , 0,
ffc1931c: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc19320: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc19324: 38 c0 00 04 li r6,4 <== NOT EXECUTED
ffc19328: 38 e1 00 0c addi r7,r1,12 <== NOT EXECUTED
ffc1932c: 4b ff f3 79 bl ffc186a4 <_fat_block_read> <== NOT EXECUTED
FAT_FSI_LEADSIG_SIZE, fs_info_sector);
if ( ret < 0 )
ffc19330: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc19334: 41 9c 02 28 blt- cr7,ffc1955c <fat_init_volume_info+0x780><== NOT EXECUTED
{
rtems_disk_release(vol->dd);
return -1;
}
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
ffc19338: 89 41 00 0d lbz r10,13(r1) <== NOT EXECUTED
ffc1933c: 89 21 00 0e lbz r9,14(r1) <== NOT EXECUTED
ffc19340: 55 4a 40 2e rlwinm r10,r10,8,0,23 <== NOT EXECUTED
ffc19344: 89 61 00 0c lbz r11,12(r1) <== NOT EXECUTED
ffc19348: 55 29 80 1e rlwinm r9,r9,16,0,15 <== NOT EXECUTED
ffc1934c: 88 01 00 0f lbz r0,15(r1) <== NOT EXECUTED
ffc19350: 7d 49 4b 78 or r9,r10,r9 <== NOT EXECUTED
ffc19354: 54 00 c0 0e rlwinm r0,r0,24,0,7 <== NOT EXECUTED
ffc19358: 7d 29 5b 78 or r9,r9,r11 <== NOT EXECUTED
ffc1935c: 7d 29 03 78 or r9,r9,r0 <== NOT EXECUTED
ffc19360: 6d 20 41 61 xoris r0,r9,16737 <== NOT EXECUTED
ffc19364: 2f 80 52 52 cmpwi cr7,r0,21074 <== NOT EXECUTED
ffc19368: 40 9e 01 44 bne- cr7,ffc194ac <fat_init_volume_info+0x6d0><== NOT EXECUTED
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
else
{
ret = _fat_block_read(mt_entry, vol->info_sec , FAT_FSI_INFO,
ffc1936c: a0 9f 00 3c lhz r4,60(r31) <== NOT EXECUTED
ffc19370: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc19374: 38 a0 01 e4 li r5,484 <== NOT EXECUTED
ffc19378: 38 c0 00 0c li r6,12 <== NOT EXECUTED
ffc1937c: 38 e1 00 0c addi r7,r1,12 <== NOT EXECUTED
ffc19380: 4b ff f3 25 bl ffc186a4 <_fat_block_read> <== NOT EXECUTED
FAT_USEFUL_INFO_SIZE, fs_info_sector);
if ( ret < 0 )
ffc19384: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc19388: 41 9c 01 cc blt- cr7,ffc19554 <fat_init_volume_info+0x778><== NOT EXECUTED
_fat_block_release(mt_entry);
rtems_disk_release(vol->dd);
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
ffc1938c: 88 a1 00 11 lbz r5,17(r1) <== NOT EXECUTED
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
ffc19390: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
_fat_block_release(mt_entry);
rtems_disk_release(vol->dd);
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
ffc19394: 89 41 00 12 lbz r10,18(r1) <== NOT EXECUTED
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
ffc19398: 38 80 ff ff li r4,-1 <== NOT EXECUTED
rtems_disk_release(vol->dd);
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
ffc1939c: 88 c1 00 15 lbz r6,21(r1) <== NOT EXECUTED
_fat_block_release(mt_entry);
rtems_disk_release(vol->dd);
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
ffc193a0: 54 a5 40 2e rlwinm r5,r5,8,0,23 <== NOT EXECUTED
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
ffc193a4: 89 61 00 16 lbz r11,22(r1) <== NOT EXECUTED
_fat_block_release(mt_entry);
rtems_disk_release(vol->dd);
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
ffc193a8: 55 4a 80 1e rlwinm r10,r10,16,0,15 <== NOT EXECUTED
ffc193ac: 88 e1 00 10 lbz r7,16(r1) <== NOT EXECUTED
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
ffc193b0: 54 c6 40 2e rlwinm r6,r6,8,0,23 <== NOT EXECUTED
_fat_block_release(mt_entry);
rtems_disk_release(vol->dd);
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
ffc193b4: 89 21 00 13 lbz r9,19(r1) <== NOT EXECUTED
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
ffc193b8: 55 6b 80 1e rlwinm r11,r11,16,0,15 <== NOT EXECUTED
ffc193bc: 89 01 00 14 lbz r8,20(r1) <== NOT EXECUTED
_fat_block_release(mt_entry);
rtems_disk_release(vol->dd);
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
ffc193c0: 7c aa 53 78 or r10,r5,r10 <== NOT EXECUTED
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
ffc193c4: 88 01 00 17 lbz r0,23(r1) <== NOT EXECUTED
ffc193c8: 7c cb 5b 78 or r11,r6,r11 <== NOT EXECUTED
_fat_block_release(mt_entry);
rtems_disk_release(vol->dd);
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
ffc193cc: 7d 4a 3b 78 or r10,r10,r7 <== NOT EXECUTED
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
ffc193d0: 7d 6b 43 78 or r11,r11,r8 <== NOT EXECUTED
_fat_block_release(mt_entry);
rtems_disk_release(vol->dd);
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
ffc193d4: 55 29 c0 0e rlwinm r9,r9,24,0,7 <== NOT EXECUTED
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
ffc193d8: 54 00 c0 0e rlwinm r0,r0,24,0,7 <== NOT EXECUTED
_fat_block_release(mt_entry);
rtems_disk_release(vol->dd);
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
ffc193dc: 7d 49 4b 78 or r9,r10,r9 <== NOT EXECUTED
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
ffc193e0: 7d 60 03 78 or r0,r11,r0 <== NOT EXECUTED
_fat_block_release(mt_entry);
rtems_disk_release(vol->dd);
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
ffc193e4: 91 3f 00 40 stw r9,64(r31) <== NOT EXECUTED
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
ffc193e8: 38 a0 ff ff li r5,-1 <== NOT EXECUTED
rtems_disk_release(vol->dd);
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
ffc193ec: 90 1f 00 44 stw r0,68(r31) <== NOT EXECUTED
rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
ffc193f0: 4b ff f8 15 bl ffc18c04 <fat_fat32_update_fsinfo_sector><== NOT EXECUTED
0xFFFFFFFF);
if ( rc != RC_OK )
ffc193f4: 7c 7d 1b 79 mr. r29,r3 <== NOT EXECUTED
ffc193f8: 41 82 fd 3c beq+ ffc19134 <fat_init_volume_info+0x358> <== NOT EXECUTED
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
ffc193fc: 80 7e 00 34 lwz r3,52(r30) <== NOT EXECUTED
ffc19400: 4b ff f1 01 bl ffc18500 <fat_buf_release> <== NOT EXECUTED
rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
0xFFFFFFFF);
if ( rc != RC_OK )
{
_fat_block_release(mt_entry);
rtems_disk_release(vol->dd);
ffc19404: 80 7f 00 60 lwz r3,96(r31) <== NOT EXECUTED
ffc19408: 4b fe dc bd bl ffc070c4 <rtems_disk_release> <== NOT EXECUTED
return rc;
ffc1940c: 4b ff fe 20 b ffc1922c <fat_init_volume_info+0x450> <== NOT EXECUTED
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);
else
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
ffc19410: 81 61 00 6c lwz r11,108(r1) <== NOT EXECUTED
ffc19414: 81 21 00 70 lwz r9,112(r1) <== NOT EXECUTED
ffc19418: 55 75 40 2e rlwinm r21,r11,8,0,23 <== NOT EXECUTED
ffc1941c: 81 41 00 68 lwz r10,104(r1) <== NOT EXECUTED
ffc19420: 55 20 80 1e rlwinm r0,r9,16,0,15 <== NOT EXECUTED
ffc19424: 81 61 00 74 lwz r11,116(r1) <== NOT EXECUTED
ffc19428: 7e b5 03 78 or r21,r21,r0 <== NOT EXECUTED
ffc1942c: 7e b5 53 78 or r21,r21,r10 <== NOT EXECUTED
ffc19430: 55 60 c0 0e rlwinm r0,r11,24,0,7 <== NOT EXECUTED
ffc19434: 7e b5 03 78 or r21,r21,r0 <== NOT EXECUTED
ffc19438: 92 bf 00 2c stw r21,44(r31) <== NOT EXECUTED
ffc1943c: 4b ff fc b0 b ffc190ec <fat_init_volume_info+0x310> <== NOT EXECUTED
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
else
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
ffc19440: 55 d3 40 2e rlwinm r19,r14,8,0,23 <== NOT EXECUTED
ffc19444: 56 31 80 1e rlwinm r17,r17,16,0,15 <== NOT EXECUTED
ffc19448: 7e 73 8b 78 or r19,r19,r17 <== NOT EXECUTED
ffc1944c: 7e 73 7b 78 or r19,r19,r15 <== NOT EXECUTED
ffc19450: 56 10 c0 0e rlwinm r16,r16,24,0,7 <== NOT EXECUTED
ffc19454: 7e 73 83 78 or r19,r19,r16 <== NOT EXECUTED
ffc19458: 92 7f 00 18 stw r19,24(r31) <== NOT EXECUTED
ffc1945c: 4b ff fc 64 b ffc190c0 <fat_init_volume_info+0x2e4> <== NOT EXECUTED
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
ffc19460: 98 7f 00 03 stb r3,3(r31)
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
ffc19464: 3b 60 02 00 li r27,512
ffc19468: 4b ff fb 4c b ffc18fb4 <fat_init_volume_info+0x1d8>
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
{
vol->type = FAT_FAT16;
ffc1946c: 38 00 00 02 li r0,2 <== NOT EXECUTED
ffc19470: 98 1f 00 0a stb r0,10(r31) <== NOT EXECUTED
vol->mask = FAT_FAT16_MASK;
ffc19474: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc19478: 60 00 ff ff ori r0,r0,65535 <== NOT EXECUTED
ffc1947c: 90 1f 00 0c stw r0,12(r31) <== NOT EXECUTED
vol->eoc_val = FAT_FAT16_EOC;
ffc19480: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc19484: 60 00 ff f8 ori r0,r0,65528 <== NOT EXECUTED
ffc19488: 90 1f 00 10 stw r0,16(r31) <== NOT EXECUTED
ffc1948c: 4b ff fc 8c b ffc19118 <fat_init_volume_info+0x33c> <== NOT EXECUTED
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
if (vol->mirror)
vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
else
vol->afat = 0;
ffc19490: 98 1f 00 50 stb r0,80(r31) <== NOT EXECUTED
ffc19494: 4b ff fe 6c b ffc19300 <fat_init_volume_info+0x524> <== NOT EXECUTED
if (rc == -1)
return rc;
/* Must be a block device. */
if (!S_ISBLK(stat_buf.st_mode))
rtems_set_errno_and_return_minus_one(ENOTTY);
ffc19498: 48 00 ad 79 bl ffc24210 <__errno> <== NOT EXECUTED
ffc1949c: 38 00 00 19 li r0,25 <== NOT EXECUTED
ffc194a0: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc194a4: 3b a0 ff ff li r29,-1 <== NOT EXECUTED
ffc194a8: 4b ff fd 84 b ffc1922c <fat_init_volume_info+0x450> <== NOT EXECUTED
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
ffc194ac: 80 7e 00 34 lwz r3,52(r30) <== NOT EXECUTED
ffc194b0: 4b ff f0 51 bl ffc18500 <fat_buf_release> <== NOT EXECUTED
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
FAT_FSINFO_LEAD_SIGNATURE_VALUE)
{
_fat_block_release(mt_entry);
rtems_disk_release(vol->dd);
ffc194b4: 80 7f 00 60 lwz r3,96(r31) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
ffc194b8: 3b a0 ff ff li r29,-1 <== NOT EXECUTED
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
FAT_FSINFO_LEAD_SIGNATURE_VALUE)
{
_fat_block_release(mt_entry);
rtems_disk_release(vol->dd);
ffc194bc: 4b fe dc 09 bl ffc070c4 <rtems_disk_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
ffc194c0: 48 00 ad 51 bl ffc24210 <__errno> <== NOT EXECUTED
ffc194c4: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc194c8: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc194cc: 4b ff fd 60 b ffc1922c <fat_init_volume_info+0x450> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
}
fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));
if (fs_info->sec_buf == NULL)
{
rtems_disk_release(vol->dd);
ffc194d0: 80 7f 00 60 lwz r3,96(r31) <== NOT EXECUTED
ffc194d4: 4b fe db f1 bl ffc070c4 <rtems_disk_release> <== NOT EXECUTED
free(fs_info->vhash);
ffc194d8: 80 7f 00 68 lwz r3,104(r31) <== NOT EXECUTED
ffc194dc: 4b fe f0 05 bl ffc084e0 <free> <== NOT EXECUTED
free(fs_info->rhash);
ffc194e0: 80 7f 00 6c lwz r3,108(r31) <== NOT EXECUTED
ffc194e4: 4b fe ef fd bl ffc084e0 <free> <== NOT EXECUTED
free(fs_info->uino);
ffc194e8: 80 7f 00 70 lwz r3,112(r31) <== NOT EXECUTED
ffc194ec: 4b fe ef f5 bl ffc084e0 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
ffc194f0: 3b a0 ff ff li r29,-1 <== NOT EXECUTED
ffc194f4: 48 00 ad 1d bl ffc24210 <__errno> <== NOT EXECUTED
ffc194f8: 38 00 00 0c li r0,12 <== NOT EXECUTED
ffc194fc: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc19500: 4b ff fd 2c b ffc1922c <fat_init_volume_info+0x450> <== NOT EXECUTED
/* Read boot record */
/* FIXME: Asserts FAT_MAX_BPB_SIZE < bdbuf block size */
sc = rtems_bdbuf_read( vol->dev, 0, &block);
if (sc != RTEMS_SUCCESSFUL)
{
rtems_disk_release(vol->dd);
ffc19504: 80 7f 00 60 lwz r3,96(r31) <== NOT EXECUTED
ffc19508: 4b fe db bd bl ffc070c4 <rtems_disk_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO);
ffc1950c: 48 00 ad 05 bl ffc24210 <__errno> <== NOT EXECUTED
ffc19510: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc19514: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc19518: 3b a0 ff ff li r29,-1 <== NOT EXECUTED
ffc1951c: 4b ff fd 10 b ffc1922c <fat_init_volume_info+0x450> <== NOT EXECUTED
memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);
sc = rtems_bdbuf_release( block);
if (sc != RTEMS_SUCCESSFUL)
{
rtems_disk_release(vol->dd);
ffc19520: 80 7f 00 60 lwz r3,96(r31) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
ffc19524: 3b a0 ff ff li r29,-1 <== NOT EXECUTED
memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);
sc = rtems_bdbuf_release( block);
if (sc != RTEMS_SUCCESSFUL)
{
rtems_disk_release(vol->dd);
ffc19528: 4b fe db 9d bl ffc070c4 <rtems_disk_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
ffc1952c: 48 00 ac e5 bl ffc24210 <__errno> <== NOT EXECUTED
ffc19530: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc19534: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc19538: 4b ff fc f4 b ffc1922c <fat_init_volume_info+0x450> <== NOT EXECUTED
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
if ( fs_info->uino == NULL )
{
rtems_disk_release(vol->dd);
ffc1953c: 80 7f 00 60 lwz r3,96(r31) <== NOT EXECUTED
ffc19540: 4b fe db 85 bl ffc070c4 <rtems_disk_release> <== NOT EXECUTED
free(fs_info->vhash);
ffc19544: 80 7f 00 68 lwz r3,104(r31) <== NOT EXECUTED
ffc19548: 4b fe ef 99 bl ffc084e0 <free> <== NOT EXECUTED
free(fs_info->rhash);
ffc1954c: 80 7f 00 6c lwz r3,108(r31) <== NOT EXECUTED
ffc19550: 4b ff ff 9c b ffc194ec <fat_init_volume_info+0x710> <== NOT EXECUTED
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
ffc19554: 80 7e 00 34 lwz r3,52(r30) <== NOT EXECUTED
ffc19558: 4b ff ef a9 bl ffc18500 <fat_buf_release> <== NOT EXECUTED
ret = _fat_block_read(mt_entry, vol->info_sec , FAT_FSI_INFO,
FAT_USEFUL_INFO_SIZE, fs_info_sector);
if ( ret < 0 )
{
_fat_block_release(mt_entry);
rtems_disk_release(vol->dd);
ffc1955c: 80 7f 00 60 lwz r3,96(r31) <== NOT EXECUTED
return -1;
ffc19560: 3b a0 ff ff li r29,-1 <== NOT EXECUTED
ret = _fat_block_read(mt_entry, vol->info_sec , FAT_FSI_INFO,
FAT_USEFUL_INFO_SIZE, fs_info_sector);
if ( ret < 0 )
{
_fat_block_release(mt_entry);
rtems_disk_release(vol->dd);
ffc19564: 4b fe db 61 bl ffc070c4 <rtems_disk_release> <== NOT EXECUTED
return -1;
ffc19568: 4b ff fc c4 b ffc1922c <fat_init_volume_info+0x450> <== NOT EXECUTED
rtems_chain_initialize_empty(fs_info->vhash + i);
fs_info->rhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
if ( fs_info->rhash == NULL )
{
rtems_disk_release(vol->dd);
ffc1956c: 80 7f 00 60 lwz r3,96(r31) <== NOT EXECUTED
ffc19570: 4b fe db 55 bl ffc070c4 <rtems_disk_release> <== NOT EXECUTED
free(fs_info->vhash);
ffc19574: 80 7f 00 68 lwz r3,104(r31) <== NOT EXECUTED
ffc19578: 4b ff ff 74 b ffc194ec <fat_init_volume_info+0x710> <== NOT EXECUTED
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
if ( fs_info->vhash == NULL )
{
rtems_disk_release(vol->dd);
ffc1957c: 80 7f 00 60 lwz r3,96(r31) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
ffc19580: 3b a0 ff ff li r29,-1 <== NOT EXECUTED
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
if ( fs_info->vhash == NULL )
{
rtems_disk_release(vol->dd);
ffc19584: 4b fe db 41 bl ffc070c4 <rtems_disk_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
ffc19588: 48 00 ac 89 bl ffc24210 <__errno> <== NOT EXECUTED
ffc1958c: 38 00 00 0c li r0,12 <== NOT EXECUTED
ffc19590: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc19594: 4b ff fc 98 b ffc1922c <fat_init_volume_info+0x450> <== NOT EXECUTED
ffc22348 <fat_scan_fat_for_free_clusters>:
uint32_t *chain,
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl
)
{
ffc22348: 94 21 ff b8 stwu r1,-72(r1)
ffc2234c: 7c 08 02 a6 mflr r0
ffc22350: 93 c1 00 40 stw r30,64(r1)
uint32_t data_cls_val = fs_info->vol.data_cls + 2;
uint32_t i = 2;
*cls_added = 0;
if (count == 0)
ffc22354: 7c be 2b 79 mr. r30,r5
uint32_t *chain,
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl
)
{
ffc22358: 90 01 00 4c stw r0,76(r1)
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cl4find = 2;
uint32_t next_cln = 0;
ffc2235c: 38 00 00 00 li r0,0
uint32_t *chain,
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl
)
{
ffc22360: 93 a1 00 3c stw r29,60(r1)
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc22364: 83 a3 00 34 lwz r29,52(r3)
uint32_t *chain,
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl
)
{
ffc22368: 92 a1 00 1c stw r21,28(r1)
ffc2236c: 7c f5 3b 78 mr r21,r7
ffc22370: 92 e1 00 24 stw r23,36(r1)
uint32_t i = 2;
*cls_added = 0;
if (count == 0)
return rc;
ffc22374: 3a e0 00 00 li r23,0
uint32_t *chain,
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl
)
{
ffc22378: 93 01 00 28 stw r24,40(r1)
ffc2237c: 93 61 00 34 stw r27,52(r1)
ffc22380: 7c 9b 23 78 mr r27,r4
ffc22384: 93 81 00 38 stw r28,56(r1)
ffc22388: 7c dc 33 78 mr r28,r6
ffc2238c: 93 e1 00 44 stw r31,68(r1)
ffc22390: 7c 7f 1b 78 mr r31,r3
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cl4find = 2;
uint32_t next_cln = 0;
uint32_t save_cln = 0;
uint32_t data_cls_val = fs_info->vol.data_cls + 2;
ffc22394: 83 1d 00 34 lwz r24,52(r29)
uint32_t *chain,
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl
)
{
ffc22398: 92 81 00 18 stw r20,24(r1)
ffc2239c: 92 c1 00 20 stw r22,32(r1)
ffc223a0: 93 21 00 2c stw r25,44(r1)
ffc223a4: 93 41 00 30 stw r26,48(r1)
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cl4find = 2;
uint32_t next_cln = 0;
ffc223a8: 90 01 00 08 stw r0,8(r1)
uint32_t save_cln = 0;
uint32_t data_cls_val = fs_info->vol.data_cls + 2;
uint32_t i = 2;
*cls_added = 0;
ffc223ac: 90 06 00 00 stw r0,0(r6)
if (count == 0)
ffc223b0: 41 82 01 00 beq- ffc224b0 <fat_scan_fat_for_free_clusters+0x168><== NEVER TAKEN
return rc;
if (fs_info->vol.next_cl != FAT_UNDEFINED_VALUE)
ffc223b4: 83 5d 00 44 lwz r26,68(r29)
ffc223b8: 2f 9a ff ff cmpwi cr7,r26,-1
ffc223bc: 41 9e 01 38 beq- cr7,ffc224f4 <fat_scan_fat_for_free_clusters+0x1ac>
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cl4find = 2;
uint32_t next_cln = 0;
uint32_t save_cln = 0;
uint32_t data_cls_val = fs_info->vol.data_cls + 2;
ffc223c0: 3b 18 00 02 addi r24,r24,2
/*
* fs_info->vol.data_cls is exactly the count of data clusters
* starting at cluster 2, so the maximum valid cluster number is
* (fs_info->vol.data_cls + 1)
*/
while (i < data_cls_val)
ffc223c4: 2b 98 00 02 cmplwi cr7,r24,2
ffc223c8: 40 9d 01 34 ble- cr7,ffc224fc <fat_scan_fat_for_free_clusters+0x1b4><== NEVER TAKEN
ffc223cc: 3b 20 00 02 li r25,2
ffc223d0: 3a c0 00 00 li r22,0
ffc223d4: 48 00 00 54 b ffc22428 <fat_scan_fat_for_free_clusters+0xe0>
* by separate 'if' statement because otherwise undo function
* wouldn't work properly
*/
if (*cls_added == 0)
{
*chain = cl4find;
ffc223d8: 93 5b 00 00 stw r26,0(r27)
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
ffc223dc: 7f e3 fb 78 mr r3,r31
ffc223e0: 7f 44 d3 78 mr r4,r26
ffc223e4: 38 a0 ff ff li r5,-1
ffc223e8: 4b ff fa b1 bl ffc21e98 <fat_set_fat_cluster>
if ( rc != RC_OK )
ffc223ec: 2c 03 00 00 cmpwi r3,0
ffc223f0: 40 82 01 88 bne- ffc22578 <fat_scan_fat_for_free_clusters+0x230><== NEVER TAKEN
return rc;
}
}
save_cln = cl4find;
(*cls_added)++;
ffc223f4: 81 3c 00 00 lwz r9,0(r28)
ffc223f8: 38 09 00 01 addi r0,r9,1
/* have we satisfied request ? */
if (*cls_added == count)
ffc223fc: 7f 9e 00 00 cmpw cr7,r30,r0
return rc;
}
}
save_cln = cl4find;
(*cls_added)++;
ffc22400: 90 1c 00 00 stw r0,0(r28)
/* have we satisfied request ? */
if (*cls_added == count)
ffc22404: 41 9e 01 48 beq- cr7,ffc2254c <fat_scan_fat_for_free_clusters+0x204><== ALWAYS TAKEN
ffc22408: 7f 56 d3 78 mr r22,r26 <== NOT EXECUTED
fat_buf_release(fs_info);
return rc;
}
}
i++;
cl4find++;
ffc2240c: 3b 5a 00 01 addi r26,r26,1
if (cl4find >= data_cls_val)
ffc22410: 7f 98 d0 40 cmplw cr7,r24,r26
*last_cl = save_cln;
fat_buf_release(fs_info);
return rc;
}
}
i++;
ffc22414: 3b 39 00 01 addi r25,r25,1
cl4find++;
if (cl4find >= data_cls_val)
ffc22418: 41 9d 00 08 bgt- cr7,ffc22420 <fat_scan_fat_for_free_clusters+0xd8><== ALWAYS TAKEN
cl4find = 2;
ffc2241c: 3b 40 00 02 li r26,2 <== NOT EXECUTED
/*
* fs_info->vol.data_cls is exactly the count of data clusters
* starting at cluster 2, so the maximum valid cluster number is
* (fs_info->vol.data_cls + 1)
*/
while (i < data_cls_val)
ffc22420: 7f 98 c8 40 cmplw cr7,r24,r25
ffc22424: 40 9d 00 dc ble- cr7,ffc22500 <fat_scan_fat_for_free_clusters+0x1b8><== NEVER TAKEN
{
rc = fat_get_fat_cluster(mt_entry, cl4find, &next_cln);
ffc22428: 7f e3 fb 78 mr r3,r31
ffc2242c: 7f 44 d3 78 mr r4,r26
ffc22430: 38 a1 00 08 addi r5,r1,8
ffc22434: 4b ff f8 01 bl ffc21c34 <fat_get_fat_cluster>
if ( rc != RC_OK )
ffc22438: 7c 77 1b 79 mr. r23,r3
ffc2243c: 40 82 00 f4 bne- ffc22530 <fat_scan_fat_for_free_clusters+0x1e8><== NEVER TAKEN
if (*cls_added != 0)
fat_free_fat_clusters_chain(mt_entry, (*chain));
return rc;
}
if (next_cln == FAT_GENFAT_FREE)
ffc22440: 80 01 00 08 lwz r0,8(r1)
ffc22444: 2f 80 00 00 cmpwi cr7,r0,0
ffc22448: 40 be ff c4 bne- cr7,ffc2240c <fat_scan_fat_for_free_clusters+0xc4>
/*
* We are enforced to process allocation of the first free cluster
* by separate 'if' statement because otherwise undo function
* wouldn't work properly
*/
if (*cls_added == 0)
ffc2244c: 80 1c 00 00 lwz r0,0(r28)
ffc22450: 2f 80 00 00 cmpwi cr7,r0,0
ffc22454: 41 be ff 84 beq- cr7,ffc223d8 <fat_scan_fat_for_free_clusters+0x90><== ALWAYS TAKEN
}
}
else
{
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
ffc22458: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc2245c: 7f 44 d3 78 mr r4,r26 <== NOT EXECUTED
ffc22460: 38 a0 ff ff li r5,-1 <== NOT EXECUTED
ffc22464: 4b ff fa 35 bl ffc21e98 <fat_set_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
ffc22468: 7c 74 1b 79 mr. r20,r3 <== NOT EXECUTED
ffc2246c: 40 82 01 14 bne- ffc22580 <fat_scan_fat_for_free_clusters+0x238><== NOT EXECUTED
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
return rc;
}
rc = fat_set_fat_cluster(mt_entry, save_cln, cl4find);
ffc22470: 7e c4 b3 78 mr r4,r22 <== NOT EXECUTED
ffc22474: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc22478: 7f 45 d3 78 mr r5,r26 <== NOT EXECUTED
ffc2247c: 4b ff fa 1d bl ffc21e98 <fat_set_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
ffc22480: 7c 76 1b 79 mr. r22,r3 <== NOT EXECUTED
ffc22484: 41 82 ff 70 beq+ ffc223f4 <fat_scan_fat_for_free_clusters+0xac><== NOT EXECUTED
{
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
ffc22488: 80 9b 00 00 lwz r4,0(r27) <== NOT EXECUTED
ffc2248c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
return rc;
}
rc = fat_set_fat_cluster(mt_entry, save_cln, cl4find);
ffc22490: 7e d7 b3 78 mr r23,r22 <== NOT EXECUTED
if ( rc != RC_OK )
{
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
ffc22494: 4b ff fd 69 bl ffc221fc <fat_free_fat_clusters_chain> <== NOT EXECUTED
/* trying to save last allocated cluster for future use */
fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_FREE);
ffc22498: 7f 44 d3 78 mr r4,r26 <== NOT EXECUTED
ffc2249c: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc224a0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc224a4: 4b ff f9 f5 bl ffc21e98 <fat_set_fat_cluster> <== NOT EXECUTED
fat_buf_release(fs_info);
ffc224a8: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc224ac: 4b ff 60 55 bl ffc18500 <fat_buf_release> <== NOT EXECUTED
fs_info->vol.free_cls -= (*cls_added);
*last_cl = save_cln;
fat_buf_release(fs_info);
return RC_OK;
}
ffc224b0: 80 01 00 4c lwz r0,76(r1)
ffc224b4: 7e e3 bb 78 mr r3,r23
ffc224b8: 82 81 00 18 lwz r20,24(r1)
ffc224bc: 7c 08 03 a6 mtlr r0
ffc224c0: 82 a1 00 1c lwz r21,28(r1)
ffc224c4: 82 c1 00 20 lwz r22,32(r1)
ffc224c8: 82 e1 00 24 lwz r23,36(r1)
ffc224cc: 83 01 00 28 lwz r24,40(r1)
ffc224d0: 83 21 00 2c lwz r25,44(r1)
ffc224d4: 83 41 00 30 lwz r26,48(r1)
ffc224d8: 83 61 00 34 lwz r27,52(r1)
ffc224dc: 83 81 00 38 lwz r28,56(r1)
ffc224e0: 83 a1 00 3c lwz r29,60(r1)
ffc224e4: 83 c1 00 40 lwz r30,64(r1)
ffc224e8: 83 e1 00 44 lwz r31,68(r1)
ffc224ec: 38 21 00 48 addi r1,r1,72
ffc224f0: 4e 80 00 20 blr
uint32_t *last_cl
)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cl4find = 2;
ffc224f4: 3b 40 00 02 li r26,2
ffc224f8: 4b ff fe c8 b ffc223c0 <fat_scan_fat_for_free_clusters+0x78>
/*
* fs_info->vol.data_cls is exactly the count of data clusters
* starting at cluster 2, so the maximum valid cluster number is
* (fs_info->vol.data_cls + 1)
*/
while (i < data_cls_val)
ffc224fc: 3a c0 00 00 li r22,0 <== NOT EXECUTED
if (cl4find >= data_cls_val)
cl4find = 2;
}
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != 0xFFFFFFFF)
ffc22500: 80 1d 00 40 lwz r0,64(r29) <== NOT EXECUTED
cl4find++;
if (cl4find >= data_cls_val)
cl4find = 2;
}
fs_info->vol.next_cl = save_cln;
ffc22504: 92 dd 00 44 stw r22,68(r29) <== NOT EXECUTED
if (fs_info->vol.free_cls != 0xFFFFFFFF)
ffc22508: 2f 80 ff ff cmpwi cr7,r0,-1 <== NOT EXECUTED
ffc2250c: 41 9e 00 10 beq- cr7,ffc2251c <fat_scan_fat_for_free_clusters+0x1d4><== NOT EXECUTED
fs_info->vol.free_cls -= (*cls_added);
ffc22510: 81 3c 00 00 lwz r9,0(r28) <== NOT EXECUTED
ffc22514: 7c 09 00 50 subf r0,r9,r0 <== NOT EXECUTED
ffc22518: 90 1d 00 40 stw r0,64(r29) <== NOT EXECUTED
*last_cl = save_cln;
ffc2251c: 92 d5 00 00 stw r22,0(r21) <== NOT EXECUTED
fat_buf_release(fs_info);
ffc22520: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
return RC_OK;
ffc22524: 3a e0 00 00 li r23,0 <== NOT EXECUTED
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != 0xFFFFFFFF)
fs_info->vol.free_cls -= (*cls_added);
*last_cl = save_cln;
fat_buf_release(fs_info);
ffc22528: 4b ff 5f d9 bl ffc18500 <fat_buf_release> <== NOT EXECUTED
return RC_OK;
ffc2252c: 4b ff ff 84 b ffc224b0 <fat_scan_fat_for_free_clusters+0x168><== NOT EXECUTED
while (i < data_cls_val)
{
rc = fat_get_fat_cluster(mt_entry, cl4find, &next_cln);
if ( rc != RC_OK )
{
if (*cls_added != 0)
ffc22530: 80 1c 00 00 lwz r0,0(r28) <== NOT EXECUTED
ffc22534: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc22538: 41 9e ff 78 beq+ cr7,ffc224b0 <fat_scan_fat_for_free_clusters+0x168><== NOT EXECUTED
fat_free_fat_clusters_chain(mt_entry, (*chain));
ffc2253c: 80 9b 00 00 lwz r4,0(r27) <== NOT EXECUTED
ffc22540: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc22544: 4b ff fc b9 bl ffc221fc <fat_free_fat_clusters_chain> <== NOT EXECUTED
ffc22548: 4b ff ff 68 b ffc224b0 <fat_scan_fat_for_free_clusters+0x168><== NOT EXECUTED
/* have we satisfied request ? */
if (*cls_added == count)
{
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != 0xFFFFFFFF)
ffc2254c: 80 1d 00 40 lwz r0,64(r29)
(*cls_added)++;
/* have we satisfied request ? */
if (*cls_added == count)
{
fs_info->vol.next_cl = save_cln;
ffc22550: 93 5d 00 44 stw r26,68(r29)
if (fs_info->vol.free_cls != 0xFFFFFFFF)
ffc22554: 2f 80 ff ff cmpwi cr7,r0,-1
ffc22558: 41 9e 00 10 beq- cr7,ffc22568 <fat_scan_fat_for_free_clusters+0x220><== ALWAYS TAKEN
fs_info->vol.free_cls -= (*cls_added);
ffc2255c: 81 3c 00 00 lwz r9,0(r28) <== NOT EXECUTED
ffc22560: 7c 09 00 50 subf r0,r9,r0 <== NOT EXECUTED
ffc22564: 90 1d 00 40 stw r0,64(r29) <== NOT EXECUTED
*last_cl = save_cln;
ffc22568: 93 55 00 00 stw r26,0(r21)
fat_buf_release(fs_info);
ffc2256c: 7f a3 eb 78 mr r3,r29
ffc22570: 4b ff 5f 91 bl ffc18500 <fat_buf_release>
return rc;
ffc22574: 4b ff ff 3c b ffc224b0 <fat_scan_fat_for_free_clusters+0x168>
* wouldn't work properly
*/
if (*cls_added == 0)
{
*chain = cl4find;
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
ffc22578: 7c 77 1b 78 mr r23,r3 <== NOT EXECUTED
ffc2257c: 4b ff ff 34 b ffc224b0 <fat_scan_fat_for_free_clusters+0x168><== NOT EXECUTED
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
if ( rc != RC_OK )
{
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
ffc22580: 80 9b 00 00 lwz r4,0(r27) <== NOT EXECUTED
ffc22584: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
}
}
else
{
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
ffc22588: 7e 97 a3 78 mr r23,r20 <== NOT EXECUTED
if ( rc != RC_OK )
{
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
ffc2258c: 4b ff fc 71 bl ffc221fc <fat_free_fat_clusters_chain> <== NOT EXECUTED
return rc;
ffc22590: 4b ff ff 20 b ffc224b0 <fat_scan_fat_for_free_clusters+0x168><== NOT EXECUTED
ffc21e98 <fat_set_fat_cluster>:
uint16_t fat16_clv = 0;
uint32_t fat32_clv = 0;
rtems_bdbuf_buffer *block0 = NULL;
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
ffc21e98: 2b 84 00 01 cmplwi cr7,r4,1
fat_set_fat_cluster(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
uint32_t in_val
)
{
ffc21e9c: 94 21 ff c8 stwu r1,-56(r1)
ffc21ea0: 7c 08 02 a6 mflr r0
ffc21ea4: 93 21 00 1c stw r25,28(r1)
ffc21ea8: 7c b9 2b 78 mr r25,r5
ffc21eac: 90 01 00 3c stw r0,60(r1)
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t sec = 0;
uint32_t ofs = 0;
uint16_t fat16_clv = 0;
uint32_t fat32_clv = 0;
rtems_bdbuf_buffer *block0 = NULL;
ffc21eb0: 38 00 00 00 li r0,0
fat_set_fat_cluster(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
uint32_t in_val
)
{
ffc21eb4: 93 c1 00 30 stw r30,48(r1)
ffc21eb8: 7c 9e 23 78 mr r30,r4
ffc21ebc: 93 e1 00 34 stw r31,52(r1)
ffc21ec0: 93 41 00 20 stw r26,32(r1)
ffc21ec4: 93 61 00 24 stw r27,36(r1)
ffc21ec8: 93 81 00 28 stw r28,40(r1)
ffc21ecc: 93 a1 00 2c stw r29,44(r1)
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc21ed0: 83 e3 00 34 lwz r31,52(r3)
uint32_t sec = 0;
uint32_t ofs = 0;
uint16_t fat16_clv = 0;
uint32_t fat32_clv = 0;
rtems_bdbuf_buffer *block0 = NULL;
ffc21ed4: 90 01 00 08 stw r0,8(r1)
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
ffc21ed8: 40 9d 00 80 ble- cr7,ffc21f58 <fat_set_fat_cluster+0xc0><== NEVER TAKEN
ffc21edc: 81 3f 00 34 lwz r9,52(r31)
ffc21ee0: 38 09 00 01 addi r0,r9,1
ffc21ee4: 7f 84 00 40 cmplw cr7,r4,r0
ffc21ee8: 41 9d 00 70 bgt- cr7,ffc21f58 <fat_set_fat_cluster+0xc0><== NEVER TAKEN
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
ffc21eec: 88 1f 00 0a lbz r0,10(r31)
ffc21ef0: 70 09 00 01 andi. r9,r0,1
ffc21ef4: 40 82 00 a0 bne- ffc21f94 <fat_set_fat_cluster+0xfc> <== ALWAYS TAKEN
ffc21ef8: 70 09 00 02 andi. r9,r0,2 <== NOT EXECUTED
ffc21efc: 8b 7f 00 02 lbz r27,2(r31) <== NOT EXECUTED
ffc21f00: 41 82 00 b0 beq- ffc21fb0 <fat_set_fat_cluster+0x118> <== NOT EXECUTED
ffc21f04: 54 9d 08 3c rlwinm r29,r4,1,0,30 <== NOT EXECUTED
ffc21f08: 80 1f 00 4c lwz r0,76(r31) <== NOT EXECUTED
ffc21f0c: 7f bb dc 30 srw r27,r29,r27 <== NOT EXECUTED
ffc21f10: 7f 7b 02 14 add r27,r27,r0 <== NOT EXECUTED
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
ffc21f14: 7f e3 fb 78 mr r3,r31
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
ffc21f18: a3 5f 00 00 lhz r26,0(r31)
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
ffc21f1c: 7f 64 db 78 mr r4,r27
ffc21f20: 38 a0 00 01 li r5,1
ffc21f24: 38 c1 00 08 addi r6,r1,8
ffc21f28: 4b ff 63 91 bl ffc182b8 <fat_buf_access>
if (rc != RC_OK)
ffc21f2c: 2c 03 00 00 cmpwi r3,0
ffc21f30: 40 82 00 38 bne- ffc21f68 <fat_set_fat_cluster+0xd0> <== NEVER TAKEN
return rc;
switch ( fs_info->vol.type )
ffc21f34: 8b 9f 00 0a lbz r28,10(r31)
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
ffc21f38: 3b 5a ff ff addi r26,r26,-1
ffc21f3c: 7f bd d0 38 and r29,r29,r26
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
if (rc != RC_OK)
return rc;
switch ( fs_info->vol.type )
ffc21f40: 2f 9c 00 02 cmpwi cr7,r28,2
ffc21f44: 41 9e 00 80 beq- cr7,ffc21fc4 <fat_set_fat_cluster+0x12c><== NEVER TAKEN
ffc21f48: 2f 9c 00 04 cmpwi cr7,r28,4
ffc21f4c: 41 9e 01 64 beq- cr7,ffc220b0 <fat_set_fat_cluster+0x218><== NEVER TAKEN
ffc21f50: 2f 9c 00 01 cmpwi cr7,r28,1
ffc21f54: 41 9e 00 c0 beq- cr7,ffc22014 <fat_set_fat_cluster+0x17c><== ALWAYS TAKEN
fat_buf_mark_modified(fs_info);
break;
default:
rtems_set_errno_and_return_minus_one(EIO);
ffc21f58: 48 00 22 b9 bl ffc24210 <__errno> <== NOT EXECUTED
ffc21f5c: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc21f60: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc21f64: 38 60 ff ff li r3,-1 <== NOT EXECUTED
break;
}
return RC_OK;
}
ffc21f68: 80 01 00 3c lwz r0,60(r1) <== NOT EXECUTED
ffc21f6c: 83 21 00 1c lwz r25,28(r1) <== NOT EXECUTED
ffc21f70: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc21f74: 83 41 00 20 lwz r26,32(r1) <== NOT EXECUTED
ffc21f78: 83 61 00 24 lwz r27,36(r1) <== NOT EXECUTED
ffc21f7c: 83 81 00 28 lwz r28,40(r1) <== NOT EXECUTED
ffc21f80: 83 a1 00 2c lwz r29,44(r1) <== NOT EXECUTED
ffc21f84: 83 c1 00 30 lwz r30,48(r1) <== NOT EXECUTED
ffc21f88: 83 e1 00 34 lwz r31,52(r1) <== NOT EXECUTED
ffc21f8c: 38 21 00 38 addi r1,r1,56 <== NOT EXECUTED
ffc21f90: 4e 80 00 20 blr <== NOT EXECUTED
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
ffc21f94: 54 9d f8 7e rlwinm r29,r4,31,1,31
ffc21f98: 8b 7f 00 02 lbz r27,2(r31)
ffc21f9c: 7f bd 22 14 add r29,r29,r4
ffc21fa0: 80 1f 00 4c lwz r0,76(r31)
ffc21fa4: 7f bb dc 30 srw r27,r29,r27
ffc21fa8: 7f 7b 02 14 add r27,r27,r0
ffc21fac: 4b ff ff 68 b ffc21f14 <fat_set_fat_cluster+0x7c>
ffc21fb0: 54 9d 10 3a rlwinm r29,r4,2,0,29 <== NOT EXECUTED
ffc21fb4: 80 1f 00 4c lwz r0,76(r31) <== NOT EXECUTED
ffc21fb8: 7f bb dc 30 srw r27,r29,r27 <== NOT EXECUTED
ffc21fbc: 7f 7b 02 14 add r27,r27,r0 <== NOT EXECUTED
ffc21fc0: 4b ff ff 54 b ffc21f14 <fat_set_fat_cluster+0x7c> <== NOT EXECUTED
}
}
break;
case FAT_FAT16:
*((uint16_t *)(block0->buffer + ofs)) =
ffc21fc4: 81 21 00 08 lwz r9,8(r1) <== NOT EXECUTED
(uint16_t )(CT_LE_W(in_val));
ffc21fc8: 57 39 04 3e clrlwi r25,r25,16 <== NOT EXECUTED
ffc21fcc: 57 20 40 2e rlwinm r0,r25,8,0,23 <== NOT EXECUTED
break;
}
return RC_OK;
}
ffc21fd0: 83 41 00 20 lwz r26,32(r1) <== NOT EXECUTED
}
}
break;
case FAT_FAT16:
*((uint16_t *)(block0->buffer + ofs)) =
ffc21fd4: 81 29 00 24 lwz r9,36(r9) <== NOT EXECUTED
(uint16_t )(CT_LE_W(in_val));
ffc21fd8: 57 39 c2 3e rlwinm r25,r25,24,8,31 <== NOT EXECUTED
ffc21fdc: 7c 19 cb 78 or r25,r0,r25 <== NOT EXECUTED
break;
}
return RC_OK;
}
ffc21fe0: 83 61 00 24 lwz r27,36(r1) <== NOT EXECUTED
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
ffc21fe4: 38 00 00 01 li r0,1 <== NOT EXECUTED
}
}
break;
case FAT_FAT16:
*((uint16_t *)(block0->buffer + ofs)) =
ffc21fe8: 7f 29 eb 2e sthx r25,r9,r29 <== NOT EXECUTED
ffc21fec: 98 1f 00 84 stb r0,132(r31) <== NOT EXECUTED
break;
}
return RC_OK;
}
ffc21ff0: 80 01 00 3c lwz r0,60(r1) <== NOT EXECUTED
ffc21ff4: 83 21 00 1c lwz r25,28(r1) <== NOT EXECUTED
ffc21ff8: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc21ffc: 83 81 00 28 lwz r28,40(r1) <== NOT EXECUTED
ffc22000: 83 a1 00 2c lwz r29,44(r1) <== NOT EXECUTED
ffc22004: 83 c1 00 30 lwz r30,48(r1) <== NOT EXECUTED
ffc22008: 83 e1 00 34 lwz r31,52(r1) <== NOT EXECUTED
ffc2200c: 38 21 00 38 addi r1,r1,56 <== NOT EXECUTED
ffc22010: 4e 80 00 20 blr <== NOT EXECUTED
return rc;
switch ( fs_info->vol.type )
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
ffc22014: 73 c0 00 01 andi. r0,r30,1
ffc22018: 41 82 01 0c beq- ffc22124 <fat_set_fat_cluster+0x28c>
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) & 0x0F;
ffc2201c: 81 21 00 08 lwz r9,8(r1)
switch ( fs_info->vol.type )
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
ffc22020: 57 39 24 36 rlwinm r25,r25,4,16,27
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) & 0x0F;
ffc22024: 81 29 00 24 lwz r9,36(r9)
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
*((uint8_t *)(block0->buffer + ofs)) =
ffc22028: 7c 09 e8 ae lbzx r0,r9,r29
ffc2202c: 54 00 07 3e clrlwi r0,r0,28
ffc22030: 7c 09 e9 ae stbx r0,r9,r29
(*((uint8_t *)(block0->buffer + ofs))) & 0x0F;
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) |
ffc22034: 81 21 00 08 lwz r9,8(r1)
ffc22038: 81 29 00 24 lwz r9,36(r9)
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) & 0x0F;
*((uint8_t *)(block0->buffer + ofs)) =
ffc2203c: 7c 09 e8 ae lbzx r0,r9,r29
ffc22040: 7c 00 cb 78 or r0,r0,r25
ffc22044: 7c 09 e9 ae stbx r0,r9,r29
(*((uint8_t *)(block0->buffer + ofs))) |
(uint8_t )(fat16_clv & 0x00FF);
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
ffc22048: a1 3f 00 00 lhz r9,0(r31)
ffc2204c: 9b 9f 00 84 stb r28,132(r31)
ffc22050: 38 09 ff ff addi r0,r9,-1
ffc22054: 7f 80 e8 00 cmpw cr7,r0,r29
ffc22058: 41 9e 01 24 beq- cr7,ffc2217c <fat_set_fat_cluster+0x2e4><== NEVER TAKEN
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) &= 0x00;
ffc2205c: 81 21 00 08 lwz r9,8(r1)
ffc22060: 3b bd 00 01 addi r29,r29,1
*((uint8_t *)(block0->buffer + ofs + 1)) =
(*((uint8_t *)(block0->buffer + ofs + 1))) |
(uint8_t )((fat16_clv & 0xFF00)>>8);
ffc22064: 57 39 c2 3e rlwinm r25,r25,24,8,31
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) &= 0x00;
ffc22068: 81 29 00 24 lwz r9,36(r9)
ffc2206c: 7c 69 e9 ae stbx r3,r9,r29
{
*((uint8_t *)(block0->buffer + ofs + 1)) =
(*((uint8_t *)(block0->buffer + ofs + 1))) & 0xF0;
*((uint8_t *)(block0->buffer + ofs+1)) =
(*((uint8_t *)(block0->buffer + ofs+1))) |
ffc22070: 81 21 00 08 lwz r9,8(r1)
ffc22074: 81 29 00 24 lwz r9,36(r9)
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) =
(*((uint8_t *)(block0->buffer + ofs + 1))) & 0xF0;
*((uint8_t *)(block0->buffer + ofs+1)) =
ffc22078: 7c 09 e8 ae lbzx r0,r9,r29
ffc2207c: 7c 19 cb 78 or r25,r0,r25
ffc22080: 7f 29 e9 ae stbx r25,r9,r29
break;
}
return RC_OK;
}
ffc22084: 80 01 00 3c lwz r0,60(r1)
ffc22088: 83 21 00 1c lwz r25,28(r1)
ffc2208c: 7c 08 03 a6 mtlr r0
ffc22090: 83 41 00 20 lwz r26,32(r1)
ffc22094: 83 61 00 24 lwz r27,36(r1)
ffc22098: 83 81 00 28 lwz r28,40(r1)
ffc2209c: 83 a1 00 2c lwz r29,44(r1)
ffc220a0: 83 c1 00 30 lwz r30,48(r1)
ffc220a4: 83 e1 00 34 lwz r31,52(r1)
ffc220a8: 38 21 00 38 addi r1,r1,56
ffc220ac: 4e 80 00 20 blr
(uint16_t )(CT_LE_W(in_val));
fat_buf_mark_modified(fs_info);
break;
case FAT_FAT32:
fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK));
ffc220b0: 57 39 01 3e clrlwi r25,r25,4 <== NOT EXECUTED
ffc220b4: 53 2b 46 3e rlwimi r11,r25,8,24,31 <== NOT EXECUTED
ffc220b8: 53 2b c4 2e rlwimi r11,r25,24,16,23 <== NOT EXECUTED
ffc220bc: 53 2b 42 1e rlwimi r11,r25,8,8,15 <== NOT EXECUTED
ffc220c0: 53 2b c0 0e rlwimi r11,r25,24,0,7 <== NOT EXECUTED
*((uint32_t *)(block0->buffer + ofs)) =
(*((uint32_t *)(block0->buffer + ofs))) & (CT_LE_L(0xF0000000));
ffc220c4: 81 21 00 08 lwz r9,8(r1) <== NOT EXECUTED
ffc220c8: 3c 00 f0 00 lis r0,-4096 <== NOT EXECUTED
ffc220cc: 81 29 00 24 lwz r9,36(r9) <== NOT EXECUTED
ffc220d0: 50 0a 46 3e rlwimi r10,r0,8,24,31 <== NOT EXECUTED
ffc220d4: 50 0a c4 2e rlwimi r10,r0,24,16,23 <== NOT EXECUTED
ffc220d8: 50 0a 42 1e rlwimi r10,r0,8,8,15 <== NOT EXECUTED
ffc220dc: 50 0a c0 0e rlwimi r10,r0,24,0,7 <== NOT EXECUTED
ffc220e0: 7c 09 e8 2e lwzx r0,r9,r29 <== NOT EXECUTED
break;
}
return RC_OK;
}
ffc220e4: 83 21 00 1c lwz r25,28(r1) <== NOT EXECUTED
case FAT_FAT32:
fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK));
*((uint32_t *)(block0->buffer + ofs)) =
(*((uint32_t *)(block0->buffer + ofs))) & (CT_LE_L(0xF0000000));
ffc220e8: 7d 40 00 38 and r0,r10,r0 <== NOT EXECUTED
break;
}
return RC_OK;
}
ffc220ec: 83 41 00 20 lwz r26,32(r1) <== NOT EXECUTED
*((uint32_t *)(block0->buffer + ofs)) =
(*((uint32_t *)(block0->buffer + ofs))) & (CT_LE_L(0xF0000000));
*((uint32_t *)(block0->buffer + ofs)) =
fat32_clv | (*((uint32_t *)(block0->buffer + ofs)));
ffc220f0: 7c 00 5b 78 or r0,r0,r11 <== NOT EXECUTED
break;
}
return RC_OK;
}
ffc220f4: 83 61 00 24 lwz r27,36(r1) <== NOT EXECUTED
fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK));
*((uint32_t *)(block0->buffer + ofs)) =
(*((uint32_t *)(block0->buffer + ofs))) & (CT_LE_L(0xF0000000));
*((uint32_t *)(block0->buffer + ofs)) =
ffc220f8: 7c 09 e9 2e stwx r0,r9,r29 <== NOT EXECUTED
ffc220fc: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc22100: 98 1f 00 84 stb r0,132(r31) <== NOT EXECUTED
break;
}
return RC_OK;
}
ffc22104: 80 01 00 3c lwz r0,60(r1) <== NOT EXECUTED
ffc22108: 83 81 00 28 lwz r28,40(r1) <== NOT EXECUTED
ffc2210c: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc22110: 83 a1 00 2c lwz r29,44(r1) <== NOT EXECUTED
ffc22114: 83 c1 00 30 lwz r30,48(r1) <== NOT EXECUTED
ffc22118: 83 e1 00 34 lwz r31,52(r1) <== NOT EXECUTED
ffc2211c: 38 21 00 38 addi r1,r1,56 <== NOT EXECUTED
ffc22120: 4e 80 00 20 blr <== NOT EXECUTED
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
*((uint8_t *)(block0->buffer + ofs)) &= 0x00;
ffc22124: 81 21 00 08 lwz r9,8(r1)
(uint8_t )((fat16_clv & 0xFF00)>>8);
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
ffc22128: 57 39 05 3e clrlwi r25,r25,20
*((uint8_t *)(block0->buffer + ofs)) &= 0x00;
ffc2212c: 81 29 00 24 lwz r9,36(r9)
ffc22130: 7c 69 e9 ae stbx r3,r9,r29
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) |
ffc22134: 81 21 00 08 lwz r9,8(r1)
ffc22138: 81 29 00 24 lwz r9,36(r9)
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
*((uint8_t *)(block0->buffer + ofs)) &= 0x00;
*((uint8_t *)(block0->buffer + ofs)) =
ffc2213c: 7c 09 e8 ae lbzx r0,r9,r29
ffc22140: 7c 00 cb 78 or r0,r0,r25
ffc22144: 7c 09 e9 ae stbx r0,r9,r29
(*((uint8_t *)(block0->buffer + ofs))) |
(uint8_t )(fat16_clv & 0x00FF);
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
ffc22148: a1 3f 00 00 lhz r9,0(r31)
ffc2214c: 9b 9f 00 84 stb r28,132(r31)
ffc22150: 38 09 ff ff addi r0,r9,-1
ffc22154: 7f 80 e8 00 cmpw cr7,r0,r29
ffc22158: 41 9e 00 6c beq- cr7,ffc221c4 <fat_set_fat_cluster+0x32c><== NEVER TAKEN
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) =
(*((uint8_t *)(block0->buffer + ofs + 1))) & 0xF0;
ffc2215c: 81 21 00 08 lwz r9,8(r1)
ffc22160: 3b bd 00 01 addi r29,r29,1
*((uint8_t *)(block0->buffer + ofs+1)) =
(*((uint8_t *)(block0->buffer + ofs+1))) |
(uint8_t )((fat16_clv & 0xFF00)>>8);
ffc22164: 57 39 c2 3e rlwinm r25,r25,24,8,31
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) =
(*((uint8_t *)(block0->buffer + ofs + 1))) & 0xF0;
ffc22168: 81 29 00 24 lwz r9,36(r9)
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) =
ffc2216c: 7c 09 e8 ae lbzx r0,r9,r29
ffc22170: 54 00 00 36 rlwinm r0,r0,0,0,27
ffc22174: 7c 09 e9 ae stbx r0,r9,r29
ffc22178: 4b ff fe f8 b ffc22070 <fat_set_fat_cluster+0x1d8>
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
ffc2217c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc22180: 38 9b 00 01 addi r4,r27,1 <== NOT EXECUTED
ffc22184: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc22188: 38 c1 00 08 addi r6,r1,8 <== NOT EXECUTED
ffc2218c: 4b ff 61 2d bl ffc182b8 <fat_buf_access> <== NOT EXECUTED
&block0);
if (rc != RC_OK)
ffc22190: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc22194: 40 a2 fd d4 bne- ffc21f68 <fat_set_fat_cluster+0xd0> <== NOT EXECUTED
return rc;
*((uint8_t *)(block0->buffer)) &= 0x00;
ffc22198: 81 21 00 08 lwz r9,8(r1) <== NOT EXECUTED
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
(uint8_t )((fat16_clv & 0xFF00)>>8);
ffc2219c: 57 39 c2 3e rlwinm r25,r25,24,8,31 <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
&block0);
if (rc != RC_OK)
return rc;
*((uint8_t *)(block0->buffer)) &= 0x00;
ffc221a0: 81 29 00 24 lwz r9,36(r9) <== NOT EXECUTED
ffc221a4: 98 69 00 00 stb r3,0(r9) <== NOT EXECUTED
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) & 0xF0;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
ffc221a8: 81 21 00 08 lwz r9,8(r1) <== NOT EXECUTED
ffc221ac: 81 29 00 24 lwz r9,36(r9) <== NOT EXECUTED
return rc;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) & 0xF0;
*((uint8_t *)(block0->buffer)) =
ffc221b0: 88 09 00 00 lbz r0,0(r9) <== NOT EXECUTED
ffc221b4: 7f 20 03 78 or r0,r25,r0 <== NOT EXECUTED
ffc221b8: 98 09 00 00 stb r0,0(r9) <== NOT EXECUTED
ffc221bc: 9b 9f 00 84 stb r28,132(r31) <== NOT EXECUTED
ffc221c0: 4b ff fd a8 b ffc21f68 <fat_set_fat_cluster+0xd0> <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
ffc221c4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc221c8: 38 9b 00 01 addi r4,r27,1 <== NOT EXECUTED
ffc221cc: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc221d0: 38 c1 00 08 addi r6,r1,8 <== NOT EXECUTED
ffc221d4: 4b ff 60 e5 bl ffc182b8 <fat_buf_access> <== NOT EXECUTED
&block0);
if (rc != RC_OK)
ffc221d8: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc221dc: 40 a2 fd 8c bne- ffc21f68 <fat_set_fat_cluster+0xd0> <== NOT EXECUTED
return rc;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) & 0xF0;
ffc221e0: 81 21 00 08 lwz r9,8(r1) <== NOT EXECUTED
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
(uint8_t )((fat16_clv & 0xFF00)>>8);
ffc221e4: 57 39 c2 3e rlwinm r25,r25,24,8,31 <== NOT EXECUTED
&block0);
if (rc != RC_OK)
return rc;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) & 0xF0;
ffc221e8: 81 29 00 24 lwz r9,36(r9) <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
&block0);
if (rc != RC_OK)
return rc;
*((uint8_t *)(block0->buffer)) =
ffc221ec: 88 09 00 00 lbz r0,0(r9) <== NOT EXECUTED
ffc221f0: 54 00 00 36 rlwinm r0,r0,0,0,27 <== NOT EXECUTED
ffc221f4: 98 09 00 00 stb r0,0(r9) <== NOT EXECUTED
ffc221f8: 4b ff ff b0 b ffc221a8 <fat_set_fat_cluster+0x310> <== NOT EXECUTED
ffc18cac <fat_shutdown_drive>:
* RC_OK on success, or -1 if error occured
* and errno set appropriately
*/
int
fat_shutdown_drive(rtems_filesystem_mount_table_entry_t *mt_entry)
{
ffc18cac: 94 21 ff e8 stwu r1,-24(r1) <== NOT EXECUTED
ffc18cb0: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc18cb4: 90 01 00 1c stw r0,28(r1) <== NOT EXECUTED
ffc18cb8: 93 c1 00 10 stw r30,16(r1) <== NOT EXECUTED
int rc = RC_OK;
ffc18cbc: 3b c0 00 00 li r30,0 <== NOT EXECUTED
* RC_OK on success, or -1 if error occured
* and errno set appropriately
*/
int
fat_shutdown_drive(rtems_filesystem_mount_table_entry_t *mt_entry)
{
ffc18cc0: 93 e1 00 14 stw r31,20(r1) <== NOT EXECUTED
ffc18cc4: 93 81 00 08 stw r28,8(r1) <== NOT EXECUTED
ffc18cc8: 93 a1 00 0c stw r29,12(r1) <== NOT EXECUTED
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc18ccc: 83 e3 00 34 lwz r31,52(r3) <== NOT EXECUTED
int i = 0;
if (fs_info->vol.type & FAT_FAT32)
ffc18cd0: 88 1f 00 0a lbz r0,10(r31) <== NOT EXECUTED
ffc18cd4: 70 09 00 04 andi. r9,r0,4 <== NOT EXECUTED
ffc18cd8: 40 82 00 e0 bne- ffc18db8 <fat_shutdown_drive+0x10c> <== NOT EXECUTED
fs_info->vol.next_cl);
if ( rc != RC_OK )
rc = -1;
}
fat_buf_release(fs_info);
ffc18cdc: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc18ce0: 4b ff f8 21 bl ffc18500 <fat_buf_release> <== NOT EXECUTED
if (rtems_bdbuf_syncdev(fs_info->vol.dev) != RTEMS_SUCCESSFUL)
ffc18ce4: 80 7f 00 58 lwz r3,88(r31) <== NOT EXECUTED
ffc18ce8: 80 9f 00 5c lwz r4,92(r31) <== NOT EXECUTED
ffc18cec: 4b ff da 51 bl ffc1673c <rtems_bdbuf_syncdev> <== NOT EXECUTED
ffc18cf0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc18cf4: 40 9e 00 e0 bne- cr7,ffc18dd4 <fat_shutdown_drive+0x128><== NOT EXECUTED
rc = -1;
ffc18cf8: 3b 80 00 00 li r28,0 <== NOT EXECUTED
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->vhash + i;
ffc18cfc: 83 bf 00 68 lwz r29,104(r31) <== NOT EXECUTED
ffc18d00: 7f bd e2 14 add r29,r29,r28 <== NOT EXECUTED
while ( (node = rtems_chain_get(the_chain)) != NULL )
ffc18d04: 48 00 00 08 b ffc18d0c <fat_shutdown_drive+0x60> <== NOT EXECUTED
free(node);
ffc18d08: 4b fe f7 d9 bl ffc084e0 <free> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
ffc18d0c: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc18d10: 4b ff 5a f1 bl ffc0e800 <_Chain_Get> <== NOT EXECUTED
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->vhash + i;
while ( (node = rtems_chain_get(the_chain)) != NULL )
ffc18d14: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc18d18: 40 9e ff f0 bne+ cr7,ffc18d08 <fat_shutdown_drive+0x5c> <== NOT EXECUTED
fat_buf_release(fs_info);
if (rtems_bdbuf_syncdev(fs_info->vol.dev) != RTEMS_SUCCESSFUL)
rc = -1;
for (i = 0; i < FAT_HASH_SIZE; i++)
ffc18d1c: 2f 9c 00 0c cmpwi cr7,r28,12 <== NOT EXECUTED
ffc18d20: 3b 9c 00 0c addi r28,r28,12 <== NOT EXECUTED
ffc18d24: 40 be ff d8 bne- cr7,ffc18cfc <fat_shutdown_drive+0x50> <== NOT EXECUTED
ffc18d28: 3b 80 00 00 li r28,0 <== NOT EXECUTED
}
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->rhash + i;
ffc18d2c: 83 bf 00 6c lwz r29,108(r31) <== NOT EXECUTED
ffc18d30: 7f bd e2 14 add r29,r29,r28 <== NOT EXECUTED
while ( (node = rtems_chain_get(the_chain)) != NULL )
ffc18d34: 48 00 00 08 b ffc18d3c <fat_shutdown_drive+0x90> <== NOT EXECUTED
free(node);
ffc18d38: 4b fe f7 a9 bl ffc084e0 <free> <== NOT EXECUTED
ffc18d3c: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc18d40: 4b ff 5a c1 bl ffc0e800 <_Chain_Get> <== NOT EXECUTED
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->rhash + i;
while ( (node = rtems_chain_get(the_chain)) != NULL )
ffc18d44: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc18d48: 40 9e ff f0 bne+ cr7,ffc18d38 <fat_shutdown_drive+0x8c> <== NOT EXECUTED
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
for (i = 0; i < FAT_HASH_SIZE; i++)
ffc18d4c: 2f 9c 00 0c cmpwi cr7,r28,12 <== NOT EXECUTED
ffc18d50: 3b 9c 00 0c addi r28,r28,12 <== NOT EXECUTED
ffc18d54: 40 be ff d8 bne- cr7,ffc18d2c <fat_shutdown_drive+0x80> <== NOT EXECUTED
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
free(fs_info->vhash);
ffc18d58: 80 7f 00 68 lwz r3,104(r31) <== NOT EXECUTED
ffc18d5c: 4b fe f7 85 bl ffc084e0 <free> <== NOT EXECUTED
free(fs_info->rhash);
ffc18d60: 80 7f 00 6c lwz r3,108(r31) <== NOT EXECUTED
ffc18d64: 4b fe f7 7d bl ffc084e0 <free> <== NOT EXECUTED
free(fs_info->uino);
ffc18d68: 80 7f 00 70 lwz r3,112(r31) <== NOT EXECUTED
ffc18d6c: 4b fe f7 75 bl ffc084e0 <free> <== NOT EXECUTED
free(fs_info->sec_buf);
ffc18d70: 80 7f 00 8c lwz r3,140(r31) <== NOT EXECUTED
ffc18d74: 4b fe f7 6d bl ffc084e0 <free> <== NOT EXECUTED
rtems_disk_release(fs_info->vol.dd);
ffc18d78: 80 7f 00 60 lwz r3,96(r31) <== NOT EXECUTED
ffc18d7c: 4b fe e3 49 bl ffc070c4 <rtems_disk_release> <== NOT EXECUTED
if (rc)
ffc18d80: 2f 9e 00 00 cmpwi cr7,r30,0 <== NOT EXECUTED
ffc18d84: 41 be 00 10 beq+ cr7,ffc18d94 <fat_shutdown_drive+0xe8> <== NOT EXECUTED
errno = EIO;
ffc18d88: 48 00 b4 89 bl ffc24210 <__errno> <== NOT EXECUTED
ffc18d8c: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc18d90: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
return rc;
}
ffc18d94: 80 01 00 1c lwz r0,28(r1) <== NOT EXECUTED
ffc18d98: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc18d9c: 83 81 00 08 lwz r28,8(r1) <== NOT EXECUTED
ffc18da0: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc18da4: 83 a1 00 0c lwz r29,12(r1) <== NOT EXECUTED
ffc18da8: 83 c1 00 10 lwz r30,16(r1) <== NOT EXECUTED
ffc18dac: 83 e1 00 14 lwz r31,20(r1) <== NOT EXECUTED
ffc18db0: 38 21 00 18 addi r1,r1,24 <== NOT EXECUTED
ffc18db4: 4e 80 00 20 blr <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
int i = 0;
if (fs_info->vol.type & FAT_FAT32)
{
rc = fat_fat32_update_fsinfo_sector(mt_entry, fs_info->vol.free_cls,
ffc18db8: 80 9f 00 40 lwz r4,64(r31) <== NOT EXECUTED
ffc18dbc: 80 bf 00 44 lwz r5,68(r31) <== NOT EXECUTED
ffc18dc0: 4b ff fe 45 bl ffc18c04 <fat_fat32_update_fsinfo_sector><== NOT EXECUTED
fs_info->vol.next_cl);
if ( rc != RC_OK )
ffc18dc4: 7c 7e 1b 79 mr. r30,r3 <== NOT EXECUTED
ffc18dc8: 41 a2 ff 14 beq- ffc18cdc <fat_shutdown_drive+0x30> <== NOT EXECUTED
rc = -1;
ffc18dcc: 3b c0 ff ff li r30,-1 <== NOT EXECUTED
ffc18dd0: 4b ff ff 0c b ffc18cdc <fat_shutdown_drive+0x30> <== NOT EXECUTED
}
fat_buf_release(fs_info);
if (rtems_bdbuf_syncdev(fs_info->vol.dev) != RTEMS_SUCCESSFUL)
rc = -1;
ffc18dd4: 3b c0 ff ff li r30,-1 <== NOT EXECUTED
ffc18dd8: 4b ff ff 20 b ffc18cf8 <fat_shutdown_drive+0x4c> <== NOT EXECUTED
ffc1fcdc <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
ffc1fcdc: 94 21 ff c8 stwu r1,-56(r1)
ffc1fce0: 7c 08 02 a6 mflr r0
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
ffc1fce4: 3d 20 00 00 lis r9,0
int fcntl(
int fd,
int cmd,
...
)
{
ffc1fce8: 90 01 00 3c stw r0,60(r1)
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
ffc1fcec: 80 09 27 1c lwz r0,10012(r9)
...
)
{
int ret;
va_list ap;
va_start( ap, cmd );
ffc1fcf0: 39 20 00 02 li r9,2
ffc1fcf4: 99 21 00 08 stb r9,8(r1)
ffc1fcf8: 39 21 00 40 addi r9,r1,64
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
ffc1fcfc: 7f 83 00 40 cmplw cr7,r3,r0
...
)
{
int ret;
va_list ap;
va_start( ap, cmd );
ffc1fd00: 91 21 00 0c stw r9,12(r1)
ffc1fd04: 39 21 00 10 addi r9,r1,16
int fcntl(
int fd,
int cmd,
...
)
{
ffc1fd08: 93 c1 00 30 stw r30,48(r1)
ffc1fd0c: 93 e1 00 34 stw r31,52(r1)
ffc1fd10: 90 a1 00 18 stw r5,24(r1)
ffc1fd14: 90 c1 00 1c stw r6,28(r1)
ffc1fd18: 90 e1 00 20 stw r7,32(r1)
int ret;
va_list ap;
va_start( ap, cmd );
ffc1fd1c: 91 21 00 10 stw r9,16(r1)
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
ffc1fd20: 40 9c 02 08 bge- cr7,ffc1ff28 <fcntl+0x24c>
iop = rtems_libio_iop( fd );
ffc1fd24: 3f e0 00 00 lis r31,0
ffc1fd28: 81 7f 27 cc lwz r11,10188(r31)
ffc1fd2c: 54 63 30 32 rlwinm r3,r3,6,0,25
ffc1fd30: 7f cb 1a 14 add r30,r11,r3
rtems_libio_check_is_open(iop);
ffc1fd34: 80 7e 00 18 lwz r3,24(r30)
ffc1fd38: 70 69 01 00 andi. r9,r3,256
ffc1fd3c: 41 82 01 ec beq- ffc1ff28 <fcntl+0x24c>
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
ffc1fd40: 2b 84 00 09 cmplwi cr7,r4,9
ffc1fd44: 40 9d 00 30 ble- cr7,ffc1fd74 <fcntl+0x98>
errno = ENOTSUP;
ret = -1;
break;
default:
errno = EINVAL;
ffc1fd48: 4b ff 4d 99 bl ffc14ae0 <__errno>
ffc1fd4c: 38 00 00 16 li r0,22
ffc1fd50: 90 03 00 00 stw r0,0(r3)
if (ret >= 0) {
int err = (*iop->pathinfo.handlers->fcntl_h)( cmd, iop );
if (err) {
errno = err;
ret = -1;
ffc1fd54: 3b e0 ff ff li r31,-1
va_list ap;
va_start( ap, cmd );
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
ffc1fd58: 80 01 00 3c lwz r0,60(r1)
ffc1fd5c: 7f e3 fb 78 mr r3,r31
ffc1fd60: 83 c1 00 30 lwz r30,48(r1)
ffc1fd64: 7c 08 03 a6 mtlr r0
ffc1fd68: 83 e1 00 34 lwz r31,52(r1)
ffc1fd6c: 38 21 00 38 addi r1,r1,56
ffc1fd70: 4e 80 00 20 blr
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
ffc1fd74: 3d 20 ff c2 lis r9,-62
ffc1fd78: 39 29 33 64 addi r9,r9,13156
ffc1fd7c: 54 8a 10 3a rlwinm r10,r4,2,0,29
ffc1fd80: 7d 49 50 2e lwzx r10,r9,r10
ffc1fd84: 7d 2a 4a 14 add r9,r10,r9
ffc1fd88: 7d 29 03 a6 mtctr r9
ffc1fd8c: 4e 80 04 20 bctr
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
ffc1fd90: 4b ff 4d 51 bl ffc14ae0 <__errno>
ffc1fd94: 38 00 00 86 li r0,134
ffc1fd98: 90 03 00 00 stw r0,0(r3)
ffc1fd9c: 4b ff ff b8 b ffc1fd54 <fcntl+0x78>
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 ) );
ffc1fda0: 89 21 00 08 lbz r9,8(r1)
ffc1fda4: 2b 89 00 07 cmplwi cr7,r9,7
ffc1fda8: 40 9d 01 68 ble- cr7,ffc1ff10 <fcntl+0x234> <== ALWAYS TAKEN
ffc1fdac: 81 61 00 0c lwz r11,12(r1) <== NOT EXECUTED
ffc1fdb0: 38 0b 00 04 addi r0,r11,4 <== NOT EXECUTED
ffc1fdb4: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
ffc1fdb8: 80 6b 00 00 lwz r3,0(r11)
rtems_libio_t *iop;
rtems_libio_t *diop;
int fd2;
int flags;
int mask;
int ret = 0;
ffc1fdbc: 3b e0 00 00 li r31,0
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 ) );
ffc1fdc0: 90 81 00 28 stw r4,40(r1)
ffc1fdc4: 4b fe 5d c5 bl ffc05b88 <rtems_libio_fcntl_flags>
/*
* XXX If we are turning on append, should we seek to the end?
*/
iop->flags = (iop->flags & ~mask) | (flags & mask);
ffc1fdc8: 39 20 fd fe li r9,-514
ffc1fdcc: 80 1e 00 18 lwz r0,24(r30)
ffc1fdd0: 70 63 02 01 andi. r3,r3,513
ffc1fdd4: 80 81 00 28 lwz r4,40(r1)
ffc1fdd8: 7d 20 00 38 and r0,r9,r0
ffc1fddc: 7c 60 03 78 or r0,r3,r0
ffc1fde0: 90 1e 00 18 stw r0,24(r30)
ffc1fde4: 48 00 00 1c b ffc1fe00 <fcntl+0x124>
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
break;
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
ffc1fde8: 90 81 00 28 stw r4,40(r1)
ffc1fdec: 4b fe 5d fd bl ffc05be8 <rtems_libio_to_fcntl_flags>
ffc1fdf0: 7c 7f 1b 78 mr r31,r3
ffc1fdf4: 80 81 00 28 lwz r4,40(r1)
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
ffc1fdf8: 2f 9f 00 00 cmpwi cr7,r31,0
ffc1fdfc: 41 bc ff 5c blt- cr7,ffc1fd58 <fcntl+0x7c> <== NEVER TAKEN
int err = (*iop->pathinfo.handlers->fcntl_h)( cmd, iop );
ffc1fe00: 81 3e 00 24 lwz r9,36(r30)
ffc1fe04: 7c 83 23 78 mr r3,r4
ffc1fe08: 7f c4 f3 78 mr r4,r30
ffc1fe0c: 80 09 00 30 lwz r0,48(r9)
ffc1fe10: 7c 09 03 a6 mtctr r0
ffc1fe14: 4e 80 04 21 bctrl
if (err) {
ffc1fe18: 7c 7e 1b 79 mr. r30,r3
ffc1fe1c: 41 82 ff 3c beq+ ffc1fd58 <fcntl+0x7c> <== ALWAYS TAKEN
errno = err;
ffc1fe20: 4b ff 4c c1 bl ffc14ae0 <__errno> <== NOT EXECUTED
ffc1fe24: 93 c3 00 00 stw r30,0(r3) <== NOT EXECUTED
ffc1fe28: 4b ff ff 2c b ffc1fd54 <fcntl+0x78> <== NOT EXECUTED
* 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 ) )
ffc1fe2c: 89 21 00 08 lbz r9,8(r1)
ffc1fe30: 2b 89 00 07 cmplwi cr7,r9,7
ffc1fe34: 41 9d 00 cc bgt- cr7,ffc1ff00 <fcntl+0x224> <== NEVER TAKEN
ffc1fe38: 55 20 10 3a rlwinm r0,r9,2,0,29
ffc1fe3c: 81 61 00 10 lwz r11,16(r1)
ffc1fe40: 39 29 00 01 addi r9,r9,1
ffc1fe44: 99 21 00 08 stb r9,8(r1)
ffc1fe48: 7d 6b 02 14 add r11,r11,r0
ffc1fe4c: 80 0b 00 00 lwz r0,0(r11)
ffc1fe50: 2f 80 00 00 cmpwi cr7,r0,0
ffc1fe54: 41 9e 00 e8 beq- cr7,ffc1ff3c <fcntl+0x260>
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
ffc1fe58: 60 63 08 00 ori r3,r3,2048
ffc1fe5c: 90 7e 00 18 stw r3,24(r30)
rtems_libio_t *iop;
rtems_libio_t *diop;
int fd2;
int flags;
int mask;
int ret = 0;
ffc1fe60: 3b e0 00 00 li r31,0
ffc1fe64: 4b ff ff 9c b ffc1fe00 <fcntl+0x124>
diop->pathinfo = iop->pathinfo;
ret = (int) (diop - rtems_libio_iops);
break;
case F_GETFD: /* get f_flags */
ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
ffc1fe68: 54 7f af fe rlwinm r31,r3,21,31,31
ffc1fe6c: 4b ff ff 94 b ffc1fe00 <fcntl+0x124>
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
case F_DUPFD: /* dup */
fd2 = va_arg( ap, int );
ffc1fe70: 89 21 00 08 lbz r9,8(r1)
ffc1fe74: 2b 89 00 07 cmplwi cr7,r9,7
ffc1fe78: 41 9d 00 78 bgt- cr7,ffc1fef0 <fcntl+0x214> <== NEVER TAKEN
ffc1fe7c: 55 2a 10 3a rlwinm r10,r9,2,0,29
ffc1fe80: 81 01 00 10 lwz r8,16(r1)
ffc1fe84: 39 29 00 01 addi r9,r9,1
ffc1fe88: 99 21 00 08 stb r9,8(r1)
ffc1fe8c: 7d 48 52 14 add r10,r8,r10
ffc1fe90: 81 4a 00 00 lwz r10,0(r10)
if ( fd2 )
ffc1fe94: 2f 8a 00 00 cmpwi cr7,r10,0
ffc1fe98: 41 9e 00 b4 beq- cr7,ffc1ff4c <fcntl+0x270>
diop = rtems_libio_iop( fd2 );
ffc1fe9c: 7f 80 50 40 cmplw cr7,r0,r10
ffc1fea0: 3b e0 00 00 li r31,0
ffc1fea4: 39 20 00 00 li r9,0
ffc1fea8: 40 9d 00 10 ble- cr7,ffc1feb8 <fcntl+0x1dc> <== NEVER TAKEN
ffc1feac: 55 49 30 32 rlwinm r9,r10,6,0,25
ffc1feb0: 7d 2b 4a 14 add r9,r11,r9
ffc1feb4: 7d 3f 4b 78 mr r31,r9
break;
}
}
diop->flags = iop->flags;
diop->pathinfo = iop->pathinfo;
ffc1feb8: 80 1e 00 28 lwz r0,40(r30)
ret = (int) (diop - rtems_libio_iops);
ffc1febc: 7f eb f8 50 subf r31,r11,r31
break;
}
}
diop->flags = iop->flags;
diop->pathinfo = iop->pathinfo;
ffc1fec0: 80 fe 00 1c lwz r7,28(r30)
ret = (int) (diop - rtems_libio_iops);
ffc1fec4: 7f ff 36 70 srawi r31,r31,6
break;
}
}
diop->flags = iop->flags;
diop->pathinfo = iop->pathinfo;
ffc1fec8: 81 1e 00 20 lwz r8,32(r30)
ffc1fecc: 81 5e 00 24 lwz r10,36(r30)
ffc1fed0: 90 e9 00 1c stw r7,28(r9)
ffc1fed4: 91 09 00 20 stw r8,32(r9)
ffc1fed8: 91 49 00 24 stw r10,36(r9)
ffc1fedc: 90 09 00 28 stw r0,40(r9)
ffc1fee0: 80 1e 00 2c lwz r0,44(r30)
ret = -1;
break;
}
}
diop->flags = iop->flags;
ffc1fee4: 90 69 00 18 stw r3,24(r9)
diop->pathinfo = iop->pathinfo;
ffc1fee8: 90 09 00 2c stw r0,44(r9)
ffc1feec: 4b ff ff 0c b ffc1fdf8 <fcntl+0x11c>
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
case F_DUPFD: /* dup */
fd2 = va_arg( ap, int );
ffc1fef0: 81 41 00 0c lwz r10,12(r1) <== NOT EXECUTED
ffc1fef4: 39 2a 00 04 addi r9,r10,4 <== NOT EXECUTED
ffc1fef8: 91 21 00 0c stw r9,12(r1) <== NOT EXECUTED
ffc1fefc: 4b ff ff 94 b ffc1fe90 <fcntl+0x1b4> <== NOT EXECUTED
* 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 ) )
ffc1ff00: 81 61 00 0c lwz r11,12(r1) <== NOT EXECUTED
ffc1ff04: 38 0b 00 04 addi r0,r11,4 <== NOT EXECUTED
ffc1ff08: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
ffc1ff0c: 4b ff ff 40 b ffc1fe4c <fcntl+0x170> <== NOT EXECUTED
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 ) );
ffc1ff10: 81 61 00 10 lwz r11,16(r1)
ffc1ff14: 55 20 10 3a rlwinm r0,r9,2,0,29
ffc1ff18: 39 29 00 01 addi r9,r9,1
ffc1ff1c: 7d 6b 02 14 add r11,r11,r0
ffc1ff20: 99 21 00 08 stb r9,8(r1)
ffc1ff24: 4b ff fe 94 b ffc1fdb8 <fcntl+0xdc>
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
ffc1ff28: 4b ff 4b b9 bl ffc14ae0 <__errno>
ffc1ff2c: 38 00 00 09 li r0,9
ffc1ff30: 90 03 00 00 stw r0,0(r3)
ffc1ff34: 3b e0 ff ff li r31,-1
ffc1ff38: 4b ff fe 20 b ffc1fd58 <fcntl+0x7c>
*/
if ( va_arg( ap, int ) )
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
ffc1ff3c: 54 63 05 66 rlwinm r3,r3,0,21,19
ffc1ff40: 90 7e 00 18 stw r3,24(r30)
rtems_libio_t *iop;
rtems_libio_t *diop;
int fd2;
int flags;
int mask;
int ret = 0;
ffc1ff44: 3b e0 00 00 li r31,0
ffc1ff48: 4b ff fe b8 b ffc1fe00 <fcntl+0x124>
fd2 = va_arg( ap, int );
if ( fd2 )
diop = rtems_libio_iop( fd2 );
else {
/* allocate a file control block */
diop = rtems_libio_allocate();
ffc1ff4c: 90 81 00 28 stw r4,40(r1)
ffc1ff50: 4b fe 5c e9 bl ffc05c38 <rtems_libio_allocate>
if ( diop == 0 ) {
ffc1ff54: 7c 69 1b 79 mr. r9,r3
ffc1ff58: 80 81 00 28 lwz r4,40(r1)
ffc1ff5c: 41 a2 fd f8 beq- ffc1fd54 <fcntl+0x78> <== NEVER TAKEN
ffc1ff60: 81 7f 27 cc lwz r11,10188(r31)
ffc1ff64: 7d 3f 4b 78 mr r31,r9
ffc1ff68: 80 7e 00 18 lwz r3,24(r30)
ffc1ff6c: 4b ff ff 4c b ffc1feb8 <fcntl+0x1dc>
ffc117f4 <fifo_open>:
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
ffc117f4: 94 21 ff d0 stwu r1,-48(r1)
ffc117f8: 7c 08 02 a6 mflr r0
ffc117fc: 93 e1 00 2c stw r31,44(r1)
static int pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
ffc11800: 3f e0 00 00 lis r31,0
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
ffc11804: 90 01 00 34 stw r0,52(r1)
static int pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
ffc11808: 80 1f 29 f8 lwz r0,10744(r31)
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
ffc1180c: 93 61 00 1c stw r27,28(r1)
static int pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
ffc11810: 3b 7f 29 f8 addi r27,r31,10744
ffc11814: 2f 80 00 00 cmpwi cr7,r0,0
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
ffc11818: 93 81 00 20 stw r28,32(r1)
ffc1181c: 7c 9c 23 78 mr r28,r4
ffc11820: 93 c1 00 28 stw r30,40(r1)
ffc11824: 7c 7e 1b 78 mr r30,r3
ffc11828: 93 41 00 18 stw r26,24(r1)
ffc1182c: 93 a1 00 24 stw r29,36(r1)
static int pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
ffc11830: 41 9e 00 c4 beq- cr7,ffc118f4 <fifo_open+0x100>
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
ffc11834: 7c 03 03 78 mr r3,r0
ffc11838: 38 80 00 00 li r4,0
ffc1183c: 38 a0 00 00 li r5,0
ffc11840: 4b ff a0 f1 bl ffc0b930 <rtems_semaphore_obtain>
}
if (sc == RTEMS_SUCCESSFUL) {
ffc11844: 3b 60 ff f4 li r27,-12
ffc11848: 2f 83 00 00 cmpwi cr7,r3,0
ffc1184c: 40 9e 00 7c bne- cr7,ffc118c8 <fifo_open+0xd4> <== NEVER TAKEN
err = pipe_lock();
if (err)
return err;
pipe = *pipep;
ffc11850: 83 be 00 00 lwz r29,0(r30)
if (pipe == NULL) {
ffc11854: 2f 9d 00 00 cmpwi cr7,r29,0
ffc11858: 41 9e 02 34 beq- cr7,ffc11a8c <fifo_open+0x298>
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
ffc1185c: 80 7d 00 28 lwz r3,40(r29)
ffc11860: 38 80 00 00 li r4,0
ffc11864: 38 a0 00 00 li r5,0
ffc11868: 4b ff a0 c9 bl ffc0b930 <rtems_semaphore_obtain>
err = -EINTR;
ffc1186c: 3b 60 ff fc li r27,-4
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
ffc11870: 2f 83 00 00 cmpwi cr7,r3,0
ffc11874: 40 9e 00 08 bne- cr7,ffc1187c <fifo_open+0x88> <== NEVER TAKEN
ffc11878: 3b 60 00 00 li r27,0
err = -EINTR;
if (*pipep == NULL) {
ffc1187c: 80 1e 00 00 lwz r0,0(r30)
ffc11880: 2f 80 00 00 cmpwi cr7,r0,0
ffc11884: 41 9e 03 1c beq- cr7,ffc11ba0 <fifo_open+0x3ac>
static void pipe_unlock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_semaphore_release(pipe_semaphore);
ffc11888: 80 7f 29 f8 lwz r3,10744(r31)
ffc1188c: 4b ff a2 31 bl ffc0babc <rtems_semaphore_release>
pipe_control_t *pipe;
unsigned int prevCounter;
int err;
err = pipe_new(pipep);
if (err)
ffc11890: 2f 9b 00 00 cmpwi cr7,r27,0
ffc11894: 40 9e 00 34 bne- cr7,ffc118c8 <fifo_open+0xd4> <== NEVER TAKEN
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
ffc11898: 80 1c 00 18 lwz r0,24(r28)
int err;
err = pipe_new(pipep);
if (err)
return err;
pipe = *pipep;
ffc1189c: 83 fe 00 00 lwz r31,0(r30)
switch (LIBIO_ACCMODE(iop)) {
ffc118a0: 54 00 07 7c rlwinm r0,r0,0,29,30
ffc118a4: 2f 80 00 04 cmpwi cr7,r0,4
ffc118a8: 41 9e 00 7c beq- cr7,ffc11924 <fifo_open+0x130>
ffc118ac: 2f 80 00 06 cmpwi cr7,r0,6
ffc118b0: 41 9e 01 8c beq- cr7,ffc11a3c <fifo_open+0x248>
ffc118b4: 2f 80 00 02 cmpwi cr7,r0,2
ffc118b8: 41 9e 01 00 beq- cr7,ffc119b8 <fifo_open+0x1c4> <== ALWAYS TAKEN
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
break;
}
PIPE_UNLOCK(pipe);
ffc118bc: 80 7f 00 28 lwz r3,40(r31)
return 0;
ffc118c0: 3b 60 00 00 li r27,0
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
break;
}
PIPE_UNLOCK(pipe);
ffc118c4: 4b ff a1 f9 bl ffc0babc <rtems_semaphore_release>
return 0;
out_error:
pipe_release(pipep, iop);
return err;
}
ffc118c8: 80 01 00 34 lwz r0,52(r1)
ffc118cc: 7f 63 db 78 mr r3,r27
ffc118d0: 83 41 00 18 lwz r26,24(r1)
ffc118d4: 7c 08 03 a6 mtlr r0
ffc118d8: 83 61 00 1c lwz r27,28(r1)
ffc118dc: 83 81 00 20 lwz r28,32(r1)
ffc118e0: 83 a1 00 24 lwz r29,36(r1)
ffc118e4: 83 c1 00 28 lwz r30,40(r1)
ffc118e8: 83 e1 00 2c lwz r31,44(r1)
ffc118ec: 38 21 00 30 addi r1,r1,48
ffc118f0: 4e 80 00 20 blr
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 );
ffc118f4: 3f a0 00 00 lis r29,0
ffc118f8: 80 7d 27 f4 lwz r3,10228(r29)
ffc118fc: 38 80 00 00 li r4,0
ffc11900: 38 a0 00 00 li r5,0
ffc11904: 4b ff a0 2d bl ffc0b930 <rtems_semaphore_obtain>
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
ffc11908: 80 1f 29 f8 lwz r0,10744(r31)
ffc1190c: 2f 80 00 00 cmpwi cr7,r0,0
ffc11910: 41 9e 02 a8 beq- cr7,ffc11bb8 <fifo_open+0x3c4> <== ALWAYS TAKEN
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
ffc11914: 80 7d 27 f4 lwz r3,10228(r29) <== NOT EXECUTED
ffc11918: 4b ff a1 a5 bl ffc0babc <rtems_semaphore_release> <== NOT EXECUTED
ffc1191c: 80 1f 29 f8 lwz r0,10744(r31) <== NOT EXECUTED
ffc11920: 4b ff ff 14 b ffc11834 <fifo_open+0x40> <== NOT EXECUTED
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
ffc11924: 81 3f 00 14 lwz r9,20(r31)
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
ffc11928: 81 7f 00 24 lwz r11,36(r31)
if (pipe->Writers ++ == 0)
ffc1192c: 2f 89 00 00 cmpwi cr7,r9,0
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
ffc11930: 38 0b 00 01 addi r0,r11,1
if (pipe->Writers ++ == 0)
ffc11934: 39 29 00 01 addi r9,r9,1
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
ffc11938: 90 1f 00 24 stw r0,36(r31)
if (pipe->Writers ++ == 0)
ffc1193c: 91 3f 00 14 stw r9,20(r31)
ffc11940: 41 9e 02 d4 beq- cr7,ffc11c14 <fifo_open+0x420> <== ALWAYS TAKEN
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
ffc11944: 80 1f 00 10 lwz r0,16(r31)
ffc11948: 2f 80 00 00 cmpwi cr7,r0,0
ffc1194c: 40 be ff 70 bne- cr7,ffc118bc <fifo_open+0xc8>
ffc11950: 80 1c 00 18 lwz r0,24(r28)
ffc11954: 70 09 00 01 andi. r9,r0,1
ffc11958: 40 82 03 00 bne- ffc11c58 <fifo_open+0x464>
err = -ENXIO;
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
ffc1195c: 83 bf 00 20 lwz r29,32(r31)
ffc11960: 48 00 00 20 b ffc11980 <fifo_open+0x18c>
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
goto out_error;
if (! PIPE_LOCK(pipe))
ffc11964: 80 7f 00 28 lwz r3,40(r31)
ffc11968: 4b ff 9f c9 bl ffc0b930 <rtems_semaphore_obtain>
ffc1196c: 2f 83 00 00 cmpwi cr7,r3,0
ffc11970: 40 9e 00 34 bne- cr7,ffc119a4 <fifo_open+0x1b0> <== NEVER TAKEN
goto out_error;
} while (prevCounter == pipe->readerCounter);
ffc11974: 80 1f 00 20 lwz r0,32(r31)
ffc11978: 7f 80 e8 00 cmpw cr7,r0,r29
ffc1197c: 40 be ff 40 bne- cr7,ffc118bc <fifo_open+0xc8> <== ALWAYS TAKEN
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
ffc11980: 80 7f 00 28 lwz r3,40(r31)
ffc11984: 4b ff a1 39 bl ffc0babc <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
ffc11988: 80 7f 00 30 lwz r3,48(r31)
ffc1198c: 38 80 00 00 li r4,0
ffc11990: 48 00 22 2d bl ffc13bbc <rtems_barrier_wait>
goto out_error;
if (! PIPE_LOCK(pipe))
ffc11994: 38 80 00 00 li r4,0
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ffc11998: 2f 83 00 00 cmpwi cr7,r3,0
goto out_error;
if (! PIPE_LOCK(pipe))
ffc1199c: 38 a0 00 00 li r5,0
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ffc119a0: 41 9e ff c4 beq+ cr7,ffc11964 <fifo_open+0x170> <== ALWAYS TAKEN
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
ffc119a4: 3b 60 ff fc li r27,-4 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
ffc119a8: 7f c3 f3 78 mr r3,r30
ffc119ac: 7f 84 e3 78 mr r4,r28
ffc119b0: 4b ff fc ed bl ffc1169c <pipe_release>
return err;
ffc119b4: 4b ff ff 14 b ffc118c8 <fifo_open+0xd4>
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
ffc119b8: 81 3f 00 10 lwz r9,16(r31)
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
ffc119bc: 81 7f 00 20 lwz r11,32(r31)
if (pipe->Readers ++ == 0)
ffc119c0: 2f 89 00 00 cmpwi cr7,r9,0
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
ffc119c4: 38 0b 00 01 addi r0,r11,1
if (pipe->Readers ++ == 0)
ffc119c8: 39 29 00 01 addi r9,r9,1
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
ffc119cc: 90 1f 00 20 stw r0,32(r31)
if (pipe->Readers ++ == 0)
ffc119d0: 91 3f 00 10 stw r9,16(r31)
ffc119d4: 41 9e 02 20 beq- cr7,ffc11bf4 <fifo_open+0x400> <== ALWAYS TAKEN
PIPE_WAKEUPWRITERS(pipe);
if (pipe->Writers == 0) {
ffc119d8: 80 1f 00 14 lwz r0,20(r31)
ffc119dc: 2f 80 00 00 cmpwi cr7,r0,0
ffc119e0: 40 be fe dc bne- cr7,ffc118bc <fifo_open+0xc8>
/* Not an error */
if (LIBIO_NODELAY(iop))
ffc119e4: 80 1c 00 18 lwz r0,24(r28)
ffc119e8: 70 09 00 01 andi. r9,r0,1
ffc119ec: 40 a2 fe d0 bne- ffc118bc <fifo_open+0xc8>
break;
prevCounter = pipe->writerCounter;
ffc119f0: 83 bf 00 24 lwz r29,36(r31)
ffc119f4: 48 00 00 20 b ffc11a14 <fifo_open+0x220>
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
goto out_error;
if (! PIPE_LOCK(pipe))
ffc119f8: 80 7f 00 28 lwz r3,40(r31)
ffc119fc: 4b ff 9f 35 bl ffc0b930 <rtems_semaphore_obtain>
ffc11a00: 2f 83 00 00 cmpwi cr7,r3,0
ffc11a04: 40 be ff a0 bne- cr7,ffc119a4 <fifo_open+0x1b0> <== NEVER TAKEN
goto out_error;
} while (prevCounter == pipe->writerCounter);
ffc11a08: 80 1f 00 24 lwz r0,36(r31)
ffc11a0c: 7f 80 e8 00 cmpw cr7,r0,r29
ffc11a10: 40 be fe ac bne- cr7,ffc118bc <fifo_open+0xc8> <== ALWAYS TAKEN
prevCounter = pipe->writerCounter;
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
ffc11a14: 80 7f 00 28 lwz r3,40(r31)
ffc11a18: 4b ff a0 a5 bl ffc0babc <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
ffc11a1c: 80 7f 00 2c lwz r3,44(r31)
ffc11a20: 38 80 00 00 li r4,0
ffc11a24: 48 00 21 99 bl ffc13bbc <rtems_barrier_wait>
goto out_error;
if (! PIPE_LOCK(pipe))
ffc11a28: 38 80 00 00 li r4,0
prevCounter = pipe->writerCounter;
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ffc11a2c: 2f 83 00 00 cmpwi cr7,r3,0
goto out_error;
if (! PIPE_LOCK(pipe))
ffc11a30: 38 a0 00 00 li r5,0
prevCounter = pipe->writerCounter;
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ffc11a34: 41 9e ff c4 beq+ cr7,ffc119f8 <fifo_open+0x204> <== ALWAYS TAKEN
ffc11a38: 4b ff ff 6c b ffc119a4 <fifo_open+0x1b0> <== NOT EXECUTED
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
ffc11a3c: 81 3f 00 10 lwz r9,16(r31)
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
ffc11a40: 81 7f 00 20 lwz r11,32(r31)
if (pipe->Readers ++ == 0)
ffc11a44: 2f 89 00 00 cmpwi cr7,r9,0
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
ffc11a48: 38 0b 00 01 addi r0,r11,1
if (pipe->Readers ++ == 0)
ffc11a4c: 39 29 00 01 addi r9,r9,1
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
ffc11a50: 90 1f 00 20 stw r0,32(r31)
if (pipe->Readers ++ == 0)
ffc11a54: 91 3f 00 10 stw r9,16(r31)
ffc11a58: 41 9e 01 ac beq- cr7,ffc11c04 <fifo_open+0x410> <== ALWAYS TAKEN
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
ffc11a5c: 81 3f 00 14 lwz r9,20(r31)
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
ffc11a60: 81 7f 00 24 lwz r11,36(r31)
if (pipe->Writers ++ == 0)
ffc11a64: 2f 89 00 00 cmpwi cr7,r9,0
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
ffc11a68: 38 0b 00 01 addi r0,r11,1
if (pipe->Writers ++ == 0)
ffc11a6c: 39 29 00 01 addi r9,r9,1
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
ffc11a70: 90 1f 00 24 stw r0,36(r31)
if (pipe->Writers ++ == 0)
ffc11a74: 91 3f 00 14 stw r9,20(r31)
ffc11a78: 40 9e fe 44 bne+ cr7,ffc118bc <fifo_open+0xc8> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
ffc11a7c: 80 7f 00 2c lwz r3,44(r31)
ffc11a80: 38 81 00 0c addi r4,r1,12
ffc11a84: 48 00 20 a5 bl ffc13b28 <rtems_barrier_release>
ffc11a88: 4b ff fe 34 b ffc118bc <fifo_open+0xc8>
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
ffc11a8c: 38 60 00 34 li r3,52
ffc11a90: 4b ff 5f c5 bl ffc07a54 <malloc>
if (pipe == NULL)
ffc11a94: 7c 7d 1b 79 mr. r29,r3
ffc11a98: 41 82 01 f0 beq- ffc11c88 <fifo_open+0x494>
return err;
memset(pipe, 0, sizeof(pipe_control_t));
ffc11a9c: 38 80 00 00 li r4,0
ffc11aa0: 38 a0 00 34 li r5,52
ffc11aa4: 48 00 5e 51 bl ffc178f4 <memset>
pipe->Size = PIPE_BUF;
ffc11aa8: 38 00 02 00 li r0,512
ffc11aac: 90 1d 00 04 stw r0,4(r29)
pipe->Buffer = malloc(pipe->Size);
ffc11ab0: 38 60 02 00 li r3,512
ffc11ab4: 4b ff 5f a1 bl ffc07a54 <malloc>
if (! pipe->Buffer)
ffc11ab8: 2f 83 00 00 cmpwi cr7,r3,0
if (pipe == NULL)
return err;
memset(pipe, 0, sizeof(pipe_control_t));
pipe->Size = PIPE_BUF;
pipe->Buffer = malloc(pipe->Size);
ffc11abc: 90 7d 00 00 stw r3,0(r29)
if (! pipe->Buffer)
ffc11ac0: 41 9e 01 c0 beq- cr7,ffc11c80 <fifo_open+0x48c> <== NEVER TAKEN
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'r', c),
ffc11ac4: 3f 60 00 00 lis r27,0
ffc11ac8: 88 7b 21 bd lbz r3,8637(r27)
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
ffc11acc: 38 80 00 00 li r4,0
ffc11ad0: 38 a0 00 00 li r5,0
ffc11ad4: 64 63 50 49 oris r3,r3,20553
ffc11ad8: 60 63 72 00 ori r3,r3,29184
ffc11adc: 38 dd 00 2c addi r6,r29,44
ffc11ae0: 48 00 1e 69 bl ffc13948 <rtems_barrier_create>
ffc11ae4: 2f 83 00 00 cmpwi cr7,r3,0
ffc11ae8: 40 9e 01 90 bne- cr7,ffc11c78 <fifo_open+0x484>
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'w', c),
ffc11aec: 88 7b 21 bd lbz r3,8637(r27)
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(
ffc11af0: 38 80 00 00 li r4,0
ffc11af4: 38 a0 00 00 li r5,0
ffc11af8: 64 63 50 49 oris r3,r3,20553
ffc11afc: 60 63 77 00 ori r3,r3,30464
ffc11b00: 38 dd 00 30 addi r6,r29,48
ffc11b04: 48 00 1e 45 bl ffc13948 <rtems_barrier_create>
ffc11b08: 2f 83 00 00 cmpwi cr7,r3,0
ffc11b0c: 40 9e 01 64 bne- cr7,ffc11c70 <fifo_open+0x47c>
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
rtems_build_name ('P', 'I', 's', c), 1,
ffc11b10: 88 7b 21 bd lbz r3,8637(r27)
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(
ffc11b14: 38 80 00 01 li r4,1
ffc11b18: 38 a0 00 10 li r5,16
ffc11b1c: 64 63 50 49 oris r3,r3,20553
ffc11b20: 60 63 73 00 ori r3,r3,29440
ffc11b24: 38 c0 00 00 li r6,0
ffc11b28: 38 fd 00 28 addi r7,r29,40
ffc11b2c: 4b ff 9b 2d bl ffc0b658 <rtems_semaphore_create>
ffc11b30: 2f 83 00 00 cmpwi cr7,r3,0
ffc11b34: 40 9e 01 34 bne- cr7,ffc11c68 <fifo_open+0x474>
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
ffc11b38: 3f 40 00 00 lis r26,0
ffc11b3c: 80 9d 00 2c lwz r4,44(r29)
ffc11b40: 3b 5a 35 5c addi r26,r26,13660
ffc11b44: 38 a1 00 08 addi r5,r1,8
ffc11b48: 7f 43 d3 78 mr r3,r26
ffc11b4c: 4b ff bd c9 bl ffc0d914 <_Objects_Get>
static void pipe_interruptible(pipe_control_t *pipe)
{
Objects_Locations location;
_Barrier_Get(pipe->readBarrier, &location)->Barrier.Wait_queue.state
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
ffc11b50: 80 03 00 4c lwz r0,76(r3)
ffc11b54: 64 00 10 00 oris r0,r0,4096
ffc11b58: 90 03 00 4c stw r0,76(r3)
_Thread_Enable_dispatch();
ffc11b5c: 4b ff ce f1 bl ffc0ea4c <_Thread_Enable_dispatch>
ffc11b60: 80 9d 00 30 lwz r4,48(r29)
ffc11b64: 38 a1 00 08 addi r5,r1,8
ffc11b68: 7f 43 d3 78 mr r3,r26
ffc11b6c: 4b ff bd a9 bl ffc0d914 <_Objects_Get>
_Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
ffc11b70: 80 03 00 4c lwz r0,76(r3)
ffc11b74: 64 00 10 00 oris r0,r0,4096
ffc11b78: 90 03 00 4c stw r0,76(r3)
_Thread_Enable_dispatch();
ffc11b7c: 4b ff ce d1 bl ffc0ea4c <_Thread_Enable_dispatch>
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
ffc11b80: 89 3b 21 bd lbz r9,8637(r27)
ffc11b84: 2f 89 00 7a cmpwi cr7,r9,122
ffc11b88: 39 29 00 01 addi r9,r9,1
ffc11b8c: 99 3b 21 bd stb r9,8637(r27)
ffc11b90: 40 9e fc cc bne+ cr7,ffc1185c <fifo_open+0x68>
c = 'a';
ffc11b94: 38 00 00 61 li r0,97
ffc11b98: 98 1b 21 bd stb r0,8637(r27)
ffc11b9c: 4b ff fc c0 b ffc1185c <fifo_open+0x68>
if (! PIPE_LOCK(pipe))
err = -EINTR;
if (*pipep == NULL) {
if (err)
ffc11ba0: 2f 9b 00 00 cmpwi cr7,r27,0
ffc11ba4: 40 9e 00 80 bne- cr7,ffc11c24 <fifo_open+0x430> <== NEVER TAKEN
pipe_free(pipe);
else
*pipep = pipe;
ffc11ba8: 93 be 00 00 stw r29,0(r30)
static void pipe_unlock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_semaphore_release(pipe_semaphore);
ffc11bac: 80 7f 29 f8 lwz r3,10744(r31)
ffc11bb0: 4b ff 9f 0d bl ffc0babc <rtems_semaphore_release>
ffc11bb4: 4b ff fc e4 b ffc11898 <fifo_open+0xa4>
if (pipe_semaphore == RTEMS_ID_NONE) {
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
sc = rtems_semaphore_create(
ffc11bb8: 3c 60 50 49 lis r3,20553
ffc11bbc: 7f 67 db 78 mr r7,r27
ffc11bc0: 38 80 00 01 li r4,1
ffc11bc4: 38 a0 00 54 li r5,84
ffc11bc8: 38 c0 00 00 li r6,0
ffc11bcc: 60 63 50 45 ori r3,r3,20549
ffc11bd0: 4b ff 9a 89 bl ffc0b658 <rtems_semaphore_create>
ffc11bd4: 7c 7b 1b 78 mr r27,r3
ffc11bd8: 80 7d 27 f4 lwz r3,10228(r29)
ffc11bdc: 4b ff 9e e1 bl ffc0babc <rtems_semaphore_release>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
ffc11be0: 2f 9b 00 00 cmpwi cr7,r27,0
ffc11be4: 3b 60 ff f4 li r27,-12
ffc11be8: 40 9e fc e0 bne+ cr7,ffc118c8 <fifo_open+0xd4>
ffc11bec: 80 1f 29 f8 lwz r0,10744(r31)
ffc11bf0: 4b ff fc 44 b ffc11834 <fifo_open+0x40>
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
ffc11bf4: 80 7f 00 30 lwz r3,48(r31)
ffc11bf8: 38 81 00 0c addi r4,r1,12
ffc11bfc: 48 00 1f 2d bl ffc13b28 <rtems_barrier_release>
ffc11c00: 4b ff fd d8 b ffc119d8 <fifo_open+0x1e4>
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
ffc11c04: 80 7f 00 30 lwz r3,48(r31)
ffc11c08: 38 81 00 0c addi r4,r1,12
ffc11c0c: 48 00 1f 1d bl ffc13b28 <rtems_barrier_release>
ffc11c10: 4b ff fe 4c b ffc11a5c <fifo_open+0x268>
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
ffc11c14: 80 7f 00 2c lwz r3,44(r31)
ffc11c18: 38 81 00 0c addi r4,r1,12
ffc11c1c: 48 00 1f 0d bl ffc13b28 <rtems_barrier_release>
ffc11c20: 4b ff fd 24 b ffc11944 <fifo_open+0x150>
/* Called with pipe_semaphore held. */
static inline void pipe_free(
pipe_control_t *pipe
)
{
rtems_barrier_delete(pipe->readBarrier);
ffc11c24: 80 7d 00 2c lwz r3,44(r29) <== NOT EXECUTED
ffc11c28: 48 00 1e 35 bl ffc13a5c <rtems_barrier_delete> <== NOT EXECUTED
rtems_barrier_delete(pipe->writeBarrier);
ffc11c2c: 80 7d 00 30 lwz r3,48(r29) <== NOT EXECUTED
ffc11c30: 48 00 1e 2d bl ffc13a5c <rtems_barrier_delete> <== NOT EXECUTED
rtems_semaphore_delete(pipe->Semaphore);
ffc11c34: 80 7d 00 28 lwz r3,40(r29) <== NOT EXECUTED
ffc11c38: 4b ff 9c 1d bl ffc0b854 <rtems_semaphore_delete> <== NOT EXECUTED
free(pipe->Buffer);
ffc11c3c: 80 7d 00 00 lwz r3,0(r29) <== NOT EXECUTED
ffc11c40: 4b ff 54 41 bl ffc07080 <free> <== NOT EXECUTED
free(pipe);
ffc11c44: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc11c48: 4b ff 54 39 bl ffc07080 <free> <== NOT EXECUTED
static void pipe_unlock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_semaphore_release(pipe_semaphore);
ffc11c4c: 80 7f 29 f8 lwz r3,10744(r31)
ffc11c50: 4b ff 9e 6d bl ffc0babc <rtems_semaphore_release>
ffc11c54: 4b ff fc 74 b ffc118c8 <fifo_open+0xd4>
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
PIPE_UNLOCK(pipe);
ffc11c58: 80 7f 00 28 lwz r3,40(r31)
err = -ENXIO;
ffc11c5c: 3b 60 ff fa li r27,-6
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
PIPE_UNLOCK(pipe);
ffc11c60: 4b ff 9e 5d bl ffc0babc <rtems_semaphore_release>
err = -ENXIO;
goto out_error;
ffc11c64: 4b ff fd 44 b ffc119a8 <fifo_open+0x1b4>
if (c ++ == 'z')
c = 'a';
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
ffc11c68: 80 7d 00 30 lwz r3,48(r29)
ffc11c6c: 48 00 1d f1 bl ffc13a5c <rtems_barrier_delete>
err_wbar:
rtems_barrier_delete(pipe->readBarrier);
ffc11c70: 80 7d 00 2c lwz r3,44(r29)
ffc11c74: 48 00 1d e9 bl ffc13a5c <rtems_barrier_delete>
err_rbar:
free(pipe->Buffer);
ffc11c78: 80 7d 00 00 lwz r3,0(r29)
ffc11c7c: 4b ff 54 05 bl ffc07080 <free>
err_buf:
free(pipe);
ffc11c80: 7f a3 eb 78 mr r3,r29
ffc11c84: 4b ff 53 fd bl ffc07080 <free>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
ffc11c88: 3b 60 ff f4 li r27,-12
ffc11c8c: 4b ff ff c0 b ffc11c4c <fifo_open+0x458>
ffc05b10 <fpathconf>:
long fpathconf(
int fd,
int name
)
{
ffc05b10: 7c 08 02 a6 mflr r0
ffc05b14: 94 21 ff f8 stwu r1,-8(r1)
long return_value;
rtems_libio_t *iop;
rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
ffc05b18: 3d 20 00 00 lis r9,0
long fpathconf(
int fd,
int name
)
{
ffc05b1c: 90 01 00 0c stw r0,12(r1)
long return_value;
rtems_libio_t *iop;
rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
ffc05b20: 80 09 27 1c lwz r0,10012(r9)
ffc05b24: 7f 83 00 40 cmplw cr7,r3,r0
ffc05b28: 40 9c 00 c8 bge- cr7,ffc05bf0 <fpathconf+0xe0>
iop = rtems_libio_iop(fd);
ffc05b2c: 3d 20 00 00 lis r9,0
ffc05b30: 80 09 27 cc lwz r0,10188(r9)
ffc05b34: 54 63 30 32 rlwinm r3,r3,6,0,25
ffc05b38: 7c 60 1a 14 add r3,r0,r3
rtems_libio_check_is_open(iop);
ffc05b3c: 80 03 00 18 lwz r0,24(r3)
ffc05b40: 70 09 01 00 andi. r9,r0,256
ffc05b44: 41 82 00 ac beq- ffc05bf0 <fpathconf+0xe0> <== NEVER TAKEN
* Now process the information request.
*/
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
switch ( name ) {
ffc05b48: 2b 84 00 0b cmplwi cr7,r4,11
/*
* Now process the information request.
*/
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
ffc05b4c: 81 23 00 2c lwz r9,44(r3)
switch ( name ) {
ffc05b50: 40 9d 00 24 ble- cr7,ffc05b74 <fpathconf+0x64>
break;
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
ffc05b54: 48 00 f0 19 bl ffc14b6c <__errno>
ffc05b58: 38 00 00 16 li r0,22
ffc05b5c: 90 03 00 00 stw r0,0(r3)
ffc05b60: 38 60 ff ff li r3,-1
break;
}
return return_value;
}
ffc05b64: 80 01 00 0c lwz r0,12(r1)
ffc05b68: 38 21 00 08 addi r1,r1,8
ffc05b6c: 7c 08 03 a6 mtlr r0
ffc05b70: 4e 80 00 20 blr
* Now process the information request.
*/
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
switch ( name ) {
ffc05b74: 3d 60 ff c2 lis r11,-62
ffc05b78: 39 6b c5 b8 addi r11,r11,-14920
ffc05b7c: 54 84 10 3a rlwinm r4,r4,2,0,29
ffc05b80: 7c 0b 20 2e lwzx r0,r11,r4
ffc05b84: 7d 60 5a 14 add r11,r0,r11
ffc05b88: 7d 69 03 a6 mtctr r11
ffc05b8c: 4e 80 04 20 bctr
break;
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
break;
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
ffc05b90: 80 69 00 5c lwz r3,92(r9)
break;
ffc05b94: 4b ff ff d0 b ffc05b64 <fpathconf+0x54>
break;
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
break;
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
ffc05b98: 80 69 00 50 lwz r3,80(r9)
break;
ffc05b9c: 4b ff ff c8 b ffc05b64 <fpathconf+0x54>
break;
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
break;
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
ffc05ba0: 80 69 00 64 lwz r3,100(r9)
break;
ffc05ba4: 4b ff ff c0 b ffc05b64 <fpathconf+0x54>
break;
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
break;
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
ffc05ba8: 80 69 00 58 lwz r3,88(r9)
break;
ffc05bac: 4b ff ff b8 b ffc05b64 <fpathconf+0x54>
break;
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
break;
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
ffc05bb0: 80 69 00 54 lwz r3,84(r9)
break;
ffc05bb4: 4b ff ff b0 b ffc05b64 <fpathconf+0x54>
break;
case _PC_PATH_MAX:
return_value = the_limits->path_max;
break;
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
ffc05bb8: 80 69 00 4c lwz r3,76(r9)
break;
ffc05bbc: 4b ff ff a8 b ffc05b64 <fpathconf+0x54>
break;
case _PC_NAME_MAX:
return_value = the_limits->name_max;
break;
case _PC_PATH_MAX:
return_value = the_limits->path_max;
ffc05bc0: 80 69 00 48 lwz r3,72(r9)
break;
ffc05bc4: 4b ff ff a0 b ffc05b64 <fpathconf+0x54>
break;
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
break;
case _PC_NAME_MAX:
return_value = the_limits->name_max;
ffc05bc8: 80 69 00 44 lwz r3,68(r9)
break;
ffc05bcc: 4b ff ff 98 b ffc05b64 <fpathconf+0x54>
break;
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
break;
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
ffc05bd0: 80 69 00 40 lwz r3,64(r9)
break;
ffc05bd4: 4b ff ff 90 b ffc05b64 <fpathconf+0x54>
switch ( name ) {
case _PC_LINK_MAX:
return_value = the_limits->link_max;
break;
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
ffc05bd8: 80 69 00 3c lwz r3,60(r9)
break;
ffc05bdc: 4b ff ff 88 b ffc05b64 <fpathconf+0x54>
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
switch ( name ) {
case _PC_LINK_MAX:
return_value = the_limits->link_max;
ffc05be0: 80 69 00 38 lwz r3,56(r9)
break;
ffc05be4: 4b ff ff 80 b ffc05b64 <fpathconf+0x54>
break;
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
break;
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
ffc05be8: 80 69 00 60 lwz r3,96(r9)
break;
ffc05bec: 4b ff ff 78 b ffc05b64 <fpathconf+0x54>
rtems_libio_t *iop;
rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
iop = rtems_libio_iop(fd);
rtems_libio_check_is_open(iop);
ffc05bf0: 48 00 ef 7d bl ffc14b6c <__errno>
ffc05bf4: 38 00 00 09 li r0,9
ffc05bf8: 90 03 00 00 stw r0,0(r3)
ffc05bfc: 38 60 ff ff li r3,-1
ffc05c00: 4b ff ff 64 b ffc05b64 <fpathconf+0x54>
ffc0519c <free>:
#include <stdlib.h>
void free(
void *ptr
)
{
ffc0519c: 94 21 ff f0 stwu r1,-16(r1)
ffc051a0: 7c 08 02 a6 mflr r0
MSBUMP(free_calls, 1);
ffc051a4: 3d 20 00 00 lis r9,0
#include <stdlib.h>
void free(
void *ptr
)
{
ffc051a8: 90 01 00 14 stw r0,20(r1)
MSBUMP(free_calls, 1);
ffc051ac: 39 29 2b 60 addi r9,r9,11104
#include <stdlib.h>
void free(
void *ptr
)
{
ffc051b0: 93 e1 00 0c stw r31,12(r1)
MSBUMP(free_calls, 1);
if ( !ptr )
ffc051b4: 7c 7f 1b 79 mr. r31,r3
void free(
void *ptr
)
{
MSBUMP(free_calls, 1);
ffc051b8: 81 69 00 0c lwz r11,12(r9)
#include <stdlib.h>
void free(
void *ptr
)
{
ffc051bc: 93 c1 00 08 stw r30,8(r1)
MSBUMP(free_calls, 1);
ffc051c0: 38 0b 00 01 addi r0,r11,1
ffc051c4: 90 09 00 0c stw r0,12(r9)
if ( !ptr )
ffc051c8: 41 82 00 6c beq- ffc05234 <free+0x98>
return;
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
ffc051cc: 3d 20 00 00 lis r9,0
ffc051d0: 80 09 28 48 lwz r0,10312(r9)
ffc051d4: 2f 80 00 03 cmpwi cr7,r0,3
ffc051d8: 41 9e 00 74 beq- cr7,ffc0524c <free+0xb0> <== ALWAYS TAKEN
}
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
ffc051dc: 3d 20 00 00 lis r9,0
ffc051e0: 81 29 27 ac lwz r9,10156(r9)
ffc051e4: 2f 89 00 00 cmpwi cr7,r9,0
ffc051e8: 41 9e 00 14 beq- cr7,ffc051fc <free+0x60>
(*rtems_malloc_statistics_helpers->at_free)(ptr);
ffc051ec: 80 09 00 08 lwz r0,8(r9)
ffc051f0: 7f e3 fb 78 mr r3,r31
ffc051f4: 7c 09 03 a6 mtctr r0
ffc051f8: 4e 80 04 21 bctrl
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
ffc051fc: 3f c0 00 00 lis r30,0
ffc05200: 80 7e 27 2c lwz r3,10028(r30)
ffc05204: 7f e4 fb 78 mr r4,r31
ffc05208: 48 00 65 f5 bl ffc0b7fc <_Protected_heap_Free>
ffc0520c: 2f 83 00 00 cmpwi cr7,r3,0
ffc05210: 40 be 00 24 bne+ cr7,ffc05234 <free+0x98>
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
ptr,
RTEMS_Malloc_Heap->area_begin,
ffc05214: 81 3e 27 2c lwz r9,10028(r30)
*/
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",
ffc05218: 3c 60 ff c2 lis r3,-62
ffc0521c: 38 63 0b b8 addi r3,r3,3000
ffc05220: 80 a9 00 18 lwz r5,24(r9)
ffc05224: 7f e4 fb 78 mr r4,r31
ffc05228: 80 c9 00 1c lwz r6,28(r9)
ffc0522c: 4c c6 31 82 crclr 4*cr1+eq
ffc05230: 48 00 11 7d bl ffc063ac <printk>
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
ffc05234: 80 01 00 14 lwz r0,20(r1)
ffc05238: 83 c1 00 08 lwz r30,8(r1)
ffc0523c: 7c 08 03 a6 mtlr r0
ffc05240: 83 e1 00 0c lwz r31,12(r1)
ffc05244: 38 21 00 10 addi r1,r1,16
ffc05248: 4e 80 00 20 blr
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() ) {
ffc0524c: 48 00 01 99 bl ffc053e4 <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()) &&
ffc05250: 2f 83 00 00 cmpwi cr7,r3,0
ffc05254: 40 9e ff 88 bne+ cr7,ffc051dc <free+0x40>
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
ffc05258: 7f e3 fb 78 mr r3,r31
ffc0525c: 48 00 02 15 bl ffc05470 <malloc_deferred_free>
return;
ffc05260: 4b ff ff d4 b ffc05234 <free+0x98>
ffc08bc4 <free_user_env>:
* NOTE: this must be called with
* thread dispatching disabled!
*/
static void
free_user_env(void *venv)
{
ffc08bc4: 94 21 ff f0 stwu r1,-16(r1)
ffc08bc8: 7c 08 02 a6 mflr r0
rtems_user_env_t *env = (rtems_user_env_t*) venv ;
if (env != &rtems_global_user_env
ffc08bcc: 3d 20 00 00 lis r9,0
* NOTE: this must be called with
* thread dispatching disabled!
*/
static void
free_user_env(void *venv)
{
ffc08bd0: 90 01 00 14 stw r0,20(r1)
rtems_user_env_t *env = (rtems_user_env_t*) venv ;
if (env != &rtems_global_user_env
ffc08bd4: 38 09 2b 70 addi r0,r9,11120
ffc08bd8: 7f 83 00 00 cmpw cr7,r3,r0
* NOTE: this must be called with
* thread dispatching disabled!
*/
static void
free_user_env(void *venv)
{
ffc08bdc: 93 e1 00 0c stw r31,12(r1)
ffc08be0: 7c 7f 1b 78 mr r31,r3
rtems_user_env_t *env = (rtems_user_env_t*) venv ;
if (env != &rtems_global_user_env
ffc08be4: 41 9e 00 1c beq- cr7,ffc08c00 <free_user_env+0x3c> <== NEVER TAKEN
#ifdef HAVE_USERENV_REFCNT
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
ffc08be8: 38 63 00 04 addi r3,r3,4
ffc08bec: 4b ff e8 e1 bl ffc074cc <rtems_filesystem_freenode>
rtems_filesystem_freenode( &env->root_directory);
ffc08bf0: 38 7f 00 18 addi r3,r31,24
ffc08bf4: 4b ff e8 d9 bl ffc074cc <rtems_filesystem_freenode>
free(env);
ffc08bf8: 7f e3 fb 78 mr r3,r31
ffc08bfc: 4b ff e8 fd bl ffc074f8 <free>
}
}
ffc08c00: 80 01 00 14 lwz r0,20(r1)
ffc08c04: 83 e1 00 0c lwz r31,12(r1)
ffc08c08: 38 21 00 10 addi r1,r1,16
ffc08c0c: 7c 08 03 a6 mtlr r0
ffc08c10: 4e 80 00 20 blr
ffc04360 <get_disk_entry>:
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major < disktab_size && disktab != NULL) {
ffc04360: 3d 20 00 00 lis r9,0
ffc04364: 80 09 28 e8 lwz r0,10472(r9)
return dd;
}
}
return NULL;
ffc04368: 39 60 00 00 li r11,0
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major < disktab_size && disktab != NULL) {
ffc0436c: 39 29 28 e8 addi r9,r9,10472
ffc04370: 7f 80 18 40 cmplw cr7,r0,r3
ffc04374: 40 9d 00 60 ble- cr7,ffc043d4 <get_disk_entry+0x74> <== NEVER TAKEN
ffc04378: 81 29 00 04 lwz r9,4(r9)
ffc0437c: 2f 89 00 00 cmpwi cr7,r9,0
ffc04380: 41 9e 00 54 beq- cr7,ffc043d4 <get_disk_entry+0x74> <== NEVER TAKEN
rtems_disk_device_table *dtab = disktab + major;
ffc04384: 54 63 18 38 rlwinm r3,r3,3,0,28
ffc04388: 7d 49 1a 14 add r10,r9,r3
if (minor < dtab->size && dtab->minor != NULL) {
ffc0438c: 80 0a 00 04 lwz r0,4(r10)
ffc04390: 7f 80 20 40 cmplw cr7,r0,r4
ffc04394: 40 9d 00 40 ble- cr7,ffc043d4 <get_disk_entry+0x74> <== NEVER TAKEN
ffc04398: 7d 29 18 2e lwzx r9,r9,r3
ffc0439c: 2f 89 00 00 cmpwi cr7,r9,0
ffc043a0: 41 9e 00 34 beq- cr7,ffc043d4 <get_disk_entry+0x74> <== NEVER TAKEN
rtems_disk_device *dd = dtab->minor [minor];
ffc043a4: 54 84 10 3a rlwinm r4,r4,2,0,29
ffc043a8: 7d 69 20 2e lwzx r11,r9,r4
if (dd != NULL && !lookup_only) {
ffc043ac: 2f 8b 00 00 cmpwi cr7,r11,0
ffc043b0: 41 9e 00 24 beq- cr7,ffc043d4 <get_disk_entry+0x74>
ffc043b4: 2f 85 00 00 cmpwi cr7,r5,0
ffc043b8: 40 9e 00 1c bne- cr7,ffc043d4 <get_disk_entry+0x74>
if (!dd->deleted) {
ffc043bc: 88 0b 00 30 lbz r0,48(r11)
ffc043c0: 2f 80 00 00 cmpwi cr7,r0,0
ffc043c4: 40 9e 00 18 bne- cr7,ffc043dc <get_disk_entry+0x7c>
++dd->uses;
ffc043c8: 81 2b 00 14 lwz r9,20(r11)
ffc043cc: 38 09 00 01 addi r0,r9,1
ffc043d0: 90 0b 00 14 stw r0,20(r11)
return dd;
}
}
return NULL;
}
ffc043d4: 7d 63 5b 78 mr r3,r11
ffc043d8: 4e 80 00 20 blr
if (dd != NULL && !lookup_only) {
if (!dd->deleted) {
++dd->uses;
} else {
dd = NULL;
ffc043dc: 39 60 00 00 li r11,0
return dd;
}
}
return NULL;
}
ffc043e0: 7d 63 5b 78 mr r3,r11
ffc043e4: 4e 80 00 20 blr
ffc20064 <getdents>:
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
ffc20064: 94 21 ff c8 stwu r1,-56(r1)
ffc20068: 7c 08 02 a6 mflr r0
rtems_filesystem_location_info_t loc;
/*
* Get the file control block structure associated with the file descriptor
*/
iop = rtems_libio_iop( dd_fd );
ffc2006c: 3d 20 00 00 lis r9,0
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
ffc20070: 90 01 00 3c stw r0,60(r1)
rtems_filesystem_location_info_t loc;
/*
* Get the file control block structure associated with the file descriptor
*/
iop = rtems_libio_iop( dd_fd );
ffc20074: 80 09 27 1c lwz r0,10012(r9)
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
ffc20078: 93 a1 00 2c stw r29,44(r1)
rtems_filesystem_location_info_t loc;
/*
* Get the file control block structure associated with the file descriptor
*/
iop = rtems_libio_iop( dd_fd );
ffc2007c: 3b a0 00 00 li r29,0
ffc20080: 7f 83 00 40 cmplw cr7,r3,r0
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
ffc20084: 93 c1 00 30 stw r30,48(r1)
ffc20088: 7c 9e 23 78 mr r30,r4
ffc2008c: 93 e1 00 34 stw r31,52(r1)
ffc20090: 7c bf 2b 78 mr r31,r5
rtems_filesystem_location_info_t loc;
/*
* Get the file control block structure associated with the file descriptor
*/
iop = rtems_libio_iop( dd_fd );
ffc20094: 40 9c 00 14 bge- cr7,ffc200a8 <getdents+0x44> <== NEVER TAKEN
ffc20098: 3d 20 00 00 lis r9,0
ffc2009c: 83 a9 27 cc lwz r29,10188(r9)
ffc200a0: 54 63 30 32 rlwinm r3,r3,6,0,25
ffc200a4: 7f bd 1a 14 add r29,r29,r3
/*
* Make sure we are working on a directory
*/
loc = iop->pathinfo;
ffc200a8: 81 3d 00 28 lwz r9,40(r29)
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY )
ffc200ac: 38 61 00 08 addi r3,r1,8
iop = rtems_libio_iop( dd_fd );
/*
* Make sure we are working on a directory
*/
loc = iop->pathinfo;
ffc200b0: 80 1d 00 2c lwz r0,44(r29)
ffc200b4: 81 1d 00 1c lwz r8,28(r29)
ffc200b8: 81 5d 00 20 lwz r10,32(r29)
ffc200bc: 81 7d 00 24 lwz r11,36(r29)
ffc200c0: 90 01 00 18 stw r0,24(r1)
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY )
ffc200c4: 80 09 00 10 lwz r0,16(r9)
iop = rtems_libio_iop( dd_fd );
/*
* Make sure we are working on a directory
*/
loc = iop->pathinfo;
ffc200c8: 91 01 00 08 stw r8,8(r1)
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY )
ffc200cc: 7c 09 03 a6 mtctr r0
iop = rtems_libio_iop( dd_fd );
/*
* Make sure we are working on a directory
*/
loc = iop->pathinfo;
ffc200d0: 91 41 00 0c stw r10,12(r1)
ffc200d4: 91 61 00 10 stw r11,16(r1)
ffc200d8: 91 21 00 14 stw r9,20(r1)
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY )
ffc200dc: 4e 80 04 21 bctrl
ffc200e0: 2f 83 00 01 cmpwi cr7,r3,1
ffc200e4: 40 9e 00 3c bne- cr7,ffc20120 <getdents+0xbc>
/*
* 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 );
ffc200e8: 81 3d 00 24 lwz r9,36(r29)
ffc200ec: 7f a3 eb 78 mr r3,r29
ffc200f0: 7f c4 f3 78 mr r4,r30
ffc200f4: 80 09 00 08 lwz r0,8(r9)
ffc200f8: 7f e5 fb 78 mr r5,r31
ffc200fc: 7c 09 03 a6 mtctr r0
ffc20100: 4e 80 04 21 bctrl
}
ffc20104: 80 01 00 3c lwz r0,60(r1)
ffc20108: 83 a1 00 2c lwz r29,44(r1)
ffc2010c: 7c 08 03 a6 mtlr r0
ffc20110: 83 c1 00 30 lwz r30,48(r1)
ffc20114: 83 e1 00 34 lwz r31,52(r1)
ffc20118: 38 21 00 38 addi r1,r1,56
ffc2011c: 4e 80 00 20 blr
/*
* Make sure we are working on a directory
*/
loc = iop->pathinfo;
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
ffc20120: 4b ff 49 c1 bl ffc14ae0 <__errno>
ffc20124: 38 00 00 14 li r0,20
ffc20128: 90 03 00 00 stw r0,0(r3)
ffc2012c: 38 60 ff ff li r3,-1
ffc20130: 4b ff ff d4 b ffc20104 <getdents+0xa0>
ffc12bcc <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 )
ffc12bcc: 81 23 00 1c lwz r9,28(r3)
return -1; /* It wasn't a directory --> return error */
ffc12bd0: 38 00 ff ff li r0,-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 )
ffc12bd4: 81 29 00 4c lwz r9,76(r9)
ffc12bd8: 2f 89 00 01 cmpwi cr7,r9,1
ffc12bdc: 40 9e 00 18 bne- cr7,ffc12bf4 <imfs_dir_open+0x28> <== NEVER TAKEN
return -1; /* It wasn't a directory --> return error */
iop->offset = 0;
ffc12be0: 39 40 00 00 li r10,0
ffc12be4: 39 60 00 00 li r11,0
ffc12be8: 91 43 00 10 stw r10,16(r3)
return 0;
ffc12bec: 38 00 00 00 li r0,0
the_jnode = (IMFS_jnode_t *) iop->pathinfo.node_access;
if ( the_jnode->type != IMFS_DIRECTORY )
return -1; /* It wasn't a directory --> return error */
iop->offset = 0;
ffc12bf0: 91 63 00 14 stw r11,20(r3)
return 0;
}
ffc12bf4: 7c 03 03 78 mr r3,r0
ffc12bf8: 4e 80 00 20 blr
ffc12bfc <imfs_dir_read>:
ssize_t imfs_dir_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
ffc12bfc: 94 21 fe b0 stwu r1,-336(r1)
ffc12c00: 7c 08 02 a6 mflr r0
ffc12c04: 90 01 01 54 stw r0,340(r1)
ffc12c08: 93 81 01 40 stw r28,320(r1)
int current_entry;
int first_entry;
int last_entry;
struct dirent tmp_dirent;
the_jnode = (IMFS_jnode_t *)iop->pathinfo.node_access;
ffc12c0c: 83 83 00 1c lwz r28,28(r3)
ssize_t imfs_dir_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
ffc12c10: 93 c1 01 48 stw r30,328(r1)
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
ffc12c14: 83 dc 00 50 lwz r30,80(r28)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
ffc12c18: 3b 9c 00 54 addi r28,r28,84
ffc12c1c: 93 01 01 30 stw r24,304(r1)
ffc12c20: 7c 98 23 78 mr r24,r4
struct dirent tmp_dirent;
the_jnode = (IMFS_jnode_t *)iop->pathinfo.node_access;
the_chain = &the_jnode->info.directory.Entries;
if ( rtems_chain_is_empty( the_chain ) )
ffc12c24: 7f 9e e0 00 cmpw cr7,r30,r28
ssize_t imfs_dir_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
ffc12c28: 93 21 01 34 stw r25,308(r1)
ffc12c2c: 7c 79 1b 78 mr r25,r3
ffc12c30: 93 41 01 38 stw r26,312(r1)
the_jnode = (IMFS_jnode_t *)iop->pathinfo.node_access;
the_chain = &the_jnode->info.directory.Entries;
if ( rtems_chain_is_empty( the_chain ) )
return 0;
ffc12c34: 3b 40 00 00 li r26,0
ssize_t imfs_dir_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
ffc12c38: 92 c1 01 28 stw r22,296(r1)
ffc12c3c: 92 e1 01 2c stw r23,300(r1)
ffc12c40: 93 61 01 3c stw r27,316(r1)
ffc12c44: 93 a1 01 44 stw r29,324(r1)
ffc12c48: 93 e1 01 4c stw r31,332(r1)
struct dirent tmp_dirent;
the_jnode = (IMFS_jnode_t *)iop->pathinfo.node_access;
the_chain = &the_jnode->info.directory.Entries;
if ( rtems_chain_is_empty( the_chain ) )
ffc12c4c: 41 9e 00 c8 beq- cr7,ffc12d14 <imfs_dir_read+0x118>
bytes_transferred = 0;
first_entry = iop->offset;
/* protect against using sizes that are not exact multiples of the */
/* -dirent- size. These could result in unexpected results */
last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent);
ffc12c50: 3f 60 0e a0 lis r27,3744
/* Move to the first of the desired directory entries */
the_node = rtems_chain_first( the_chain );
bytes_transferred = 0;
first_entry = iop->offset;
ffc12c54: 83 a3 00 14 lwz r29,20(r3)
/* protect against using sizes that are not exact multiples of the */
/* -dirent- size. These could result in unexpected results */
last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent);
ffc12c58: 54 a5 e8 fe rlwinm r5,r5,29,3,31
ffc12c5c: 63 7b ea 0f ori r27,r27,59919
ffc12c60: 7f 65 d8 16 mulhwu r27,r5,r27
ffc12c64: 57 7b f8 7e rlwinm r27,r27,31,1,31
ffc12c68: 1f 7b 01 18 mulli r27,r27,280
/* The directory was not empty so try to move to the desired entry in chain*/
for (
ffc12c6c: 7f 7b ea 15 add. r27,r27,r29
ffc12c70: 40 81 00 a4 ble- ffc12d14 <imfs_dir_read+0x118> <== NEVER TAKEN
current_entry = 0;
current_entry < last_entry;
current_entry = current_entry + sizeof(struct dirent) ){
if ( rtems_chain_is_tail( the_chain, the_node ) ){
ffc12c74: 3b e0 00 00 li r31,0
}
if( current_entry >= first_entry ) {
/* Move the entry to the return buffer */
tmp_dirent.d_off = current_entry;
tmp_dirent.d_reclen = sizeof( struct dirent );
ffc12c78: 3a e0 01 18 li r23,280
ffc12c7c: 48 00 00 1c b ffc12c98 <imfs_dir_read+0x9c>
* to the end of the exisiting file, the remaining entries will be placed in
* the buffer and the returned value will be equal to -m actual- times the
* size of a directory entry.
*/
ssize_t imfs_dir_read(
ffc12c80: 3b ff 01 18 addi r31,r31,280
);
iop->offset = iop->offset + sizeof(struct dirent);
bytes_transferred = bytes_transferred + sizeof( struct dirent );
}
the_node = the_node->next;
ffc12c84: 83 de 00 00 lwz r30,0(r30)
/* protect against using sizes that are not exact multiples of the */
/* -dirent- size. These could result in unexpected results */
last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent);
/* The directory was not empty so try to move to the desired entry in chain*/
for (
ffc12c88: 7f 9b f8 00 cmpw cr7,r27,r31
current_entry = 0;
current_entry < last_entry;
current_entry = current_entry + sizeof(struct dirent) ){
if ( rtems_chain_is_tail( the_chain, the_node ) ){
ffc12c8c: 7f 1e e0 00 cmpw cr6,r30,r28
/* protect against using sizes that are not exact multiples of the */
/* -dirent- size. These could result in unexpected results */
last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent);
/* The directory was not empty so try to move to the desired entry in chain*/
for (
ffc12c90: 40 9d 00 84 ble- cr7,ffc12d14 <imfs_dir_read+0x118> <== NEVER TAKEN
current_entry = 0;
current_entry < last_entry;
current_entry = current_entry + sizeof(struct dirent) ){
if ( rtems_chain_is_tail( the_chain, the_node ) ){
ffc12c94: 41 9a 00 80 beq- cr6,ffc12d14 <imfs_dir_read+0x118>
/* entry in the read */
return bytes_transferred; /* Indicate that there are no more */
/* entries to return */
}
if( current_entry >= first_entry ) {
ffc12c98: 7f 9d f8 00 cmpw cr7,r29,r31
ffc12c9c: 41 9d ff e4 bgt+ cr7,ffc12c80 <imfs_dir_read+0x84>
/* Move the entry to the return buffer */
tmp_dirent.d_off = current_entry;
tmp_dirent.d_reclen = sizeof( struct dirent );
the_jnode = (IMFS_jnode_t *) the_node;
tmp_dirent.d_ino = the_jnode->st_ino;
ffc12ca0: 80 1e 00 38 lwz r0,56(r30)
tmp_dirent.d_namlen = strlen( the_jnode->name );
ffc12ca4: 3a de 00 0c addi r22,r30,12
/* entries to return */
}
if( current_entry >= first_entry ) {
/* Move the entry to the return buffer */
tmp_dirent.d_off = current_entry;
ffc12ca8: 7f e9 fe 70 srawi r9,r31,31
ffc12cac: 93 e1 00 14 stw r31,20(r1)
tmp_dirent.d_reclen = sizeof( struct dirent );
the_jnode = (IMFS_jnode_t *) the_node;
tmp_dirent.d_ino = the_jnode->st_ino;
tmp_dirent.d_namlen = strlen( the_jnode->name );
ffc12cb0: 7e c3 b3 78 mr r3,r22
/* entries to return */
}
if( current_entry >= first_entry ) {
/* Move the entry to the return buffer */
tmp_dirent.d_off = current_entry;
ffc12cb4: 91 21 00 10 stw r9,16(r1)
* to the end of the exisiting file, the remaining entries will be placed in
* the buffer and the returned value will be equal to -m actual- times the
* size of a directory entry.
*/
ssize_t imfs_dir_read(
ffc12cb8: 3b ff 01 18 addi r31,r31,280
if( current_entry >= first_entry ) {
/* Move the entry to the return buffer */
tmp_dirent.d_off = current_entry;
tmp_dirent.d_reclen = sizeof( struct dirent );
the_jnode = (IMFS_jnode_t *) the_node;
tmp_dirent.d_ino = the_jnode->st_ino;
ffc12cbc: 90 01 00 08 stw r0,8(r1)
}
if( current_entry >= first_entry ) {
/* Move the entry to the return buffer */
tmp_dirent.d_off = current_entry;
tmp_dirent.d_reclen = sizeof( struct dirent );
ffc12cc0: b2 e1 00 18 sth r23,24(r1)
the_jnode = (IMFS_jnode_t *) the_node;
tmp_dirent.d_ino = the_jnode->st_ino;
tmp_dirent.d_namlen = strlen( the_jnode->name );
ffc12cc4: 48 00 29 f5 bl ffc156b8 <strlen>
strcpy( tmp_dirent.d_name, the_jnode->name );
ffc12cc8: 7e c4 b3 78 mr r4,r22
/* Move the entry to the return buffer */
tmp_dirent.d_off = current_entry;
tmp_dirent.d_reclen = sizeof( struct dirent );
the_jnode = (IMFS_jnode_t *) the_node;
tmp_dirent.d_ino = the_jnode->st_ino;
tmp_dirent.d_namlen = strlen( the_jnode->name );
ffc12ccc: b0 61 00 1a sth r3,26(r1)
strcpy( tmp_dirent.d_name, the_jnode->name );
ffc12cd0: 38 61 00 1c addi r3,r1,28
ffc12cd4: 48 00 24 d1 bl ffc151a4 <strcpy>
memcpy(
ffc12cd8: 7c 78 d2 14 add r3,r24,r26
ffc12cdc: 38 81 00 08 addi r4,r1,8
ffc12ce0: 38 a0 01 18 li r5,280
ffc12ce4: 48 00 1d e5 bl ffc14ac8 <memcpy>
/* protect against using sizes that are not exact multiples of the */
/* -dirent- size. These could result in unexpected results */
last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent);
/* The directory was not empty so try to move to the desired entry in chain*/
for (
ffc12ce8: 7f 9b f8 00 cmpw cr7,r27,r31
memcpy(
buffer + bytes_transferred,
(void *)&tmp_dirent,
sizeof( struct dirent )
);
iop->offset = iop->offset + sizeof(struct dirent);
ffc12cec: 81 59 00 10 lwz r10,16(r25)
bytes_transferred = bytes_transferred + sizeof( struct dirent );
ffc12cf0: 3b 5a 01 18 addi r26,r26,280
memcpy(
buffer + bytes_transferred,
(void *)&tmp_dirent,
sizeof( struct dirent )
);
iop->offset = iop->offset + sizeof(struct dirent);
ffc12cf4: 81 79 00 14 lwz r11,20(r25)
bytes_transferred = bytes_transferred + sizeof( struct dirent );
}
the_node = the_node->next;
ffc12cf8: 83 de 00 00 lwz r30,0(r30)
memcpy(
buffer + bytes_transferred,
(void *)&tmp_dirent,
sizeof( struct dirent )
);
iop->offset = iop->offset + sizeof(struct dirent);
ffc12cfc: 31 6b 01 18 addic r11,r11,280
ffc12d00: 7d 4a 01 94 addze r10,r10
ffc12d04: 91 59 00 10 stw r10,16(r25)
for (
current_entry = 0;
current_entry < last_entry;
current_entry = current_entry + sizeof(struct dirent) ){
if ( rtems_chain_is_tail( the_chain, the_node ) ){
ffc12d08: 7f 1e e0 00 cmpw cr6,r30,r28
memcpy(
buffer + bytes_transferred,
(void *)&tmp_dirent,
sizeof( struct dirent )
);
iop->offset = iop->offset + sizeof(struct dirent);
ffc12d0c: 91 79 00 14 stw r11,20(r25)
/* protect against using sizes that are not exact multiples of the */
/* -dirent- size. These could result in unexpected results */
last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent);
/* The directory was not empty so try to move to the desired entry in chain*/
for (
ffc12d10: 41 9d ff 84 bgt+ cr7,ffc12c94 <imfs_dir_read+0x98> <== NEVER TAKEN
the_node = the_node->next;
}
/* Success */
return bytes_transferred;
}
ffc12d14: 80 01 01 54 lwz r0,340(r1)
ffc12d18: 7f 43 d3 78 mr r3,r26
ffc12d1c: 82 c1 01 28 lwz r22,296(r1)
ffc12d20: 7c 08 03 a6 mtlr r0
ffc12d24: 82 e1 01 2c lwz r23,300(r1)
ffc12d28: 83 01 01 30 lwz r24,304(r1)
ffc12d2c: 83 21 01 34 lwz r25,308(r1)
ffc12d30: 83 41 01 38 lwz r26,312(r1)
ffc12d34: 83 61 01 3c lwz r27,316(r1)
ffc12d38: 83 81 01 40 lwz r28,320(r1)
ffc12d3c: 83 a1 01 44 lwz r29,324(r1)
ffc12d40: 83 c1 01 48 lwz r30,328(r1)
ffc12d44: 83 e1 01 4c lwz r31,332(r1)
ffc12d48: 38 21 01 50 addi r1,r1,336
ffc12d4c: 4e 80 00 20 blr
ffc12ebc <imfs_dir_rmnod>:
int imfs_dir_rmnod(
rtems_filesystem_location_info_t *parent_pathloc, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN */
)
{
ffc12ebc: 94 21 ff f0 stwu r1,-16(r1)
ffc12ec0: 7c 08 02 a6 mflr r0
ffc12ec4: 93 e1 00 0c stw r31,12(r1)
ffc12ec8: 90 01 00 14 stw r0,20(r1)
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
ffc12ecc: 83 e4 00 00 lwz r31,0(r4)
/*
* You cannot remove a node that still has children
*/
if ( ! rtems_chain_is_empty( &the_jnode->info.directory.Entries ) )
ffc12ed0: 81 3f 00 50 lwz r9,80(r31)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
ffc12ed4: 38 1f 00 54 addi r0,r31,84
ffc12ed8: 7f 89 00 00 cmpw cr7,r9,r0
ffc12edc: 40 9e 00 6c bne- cr7,ffc12f48 <imfs_dir_rmnod+0x8c>
static inline bool rtems_filesystem_is_root_location(
const rtems_filesystem_location_info_t *loc
)
{
return loc->mt_entry->mt_fs_root.node_access == loc->node_access;
ffc12ee0: 81 24 00 10 lwz r9,16(r4)
/*
* You cannot remove the file system root node.
*/
if ( rtems_filesystem_is_root_location(pathloc) )
ffc12ee4: 80 09 00 1c lwz r0,28(r9)
ffc12ee8: 7f 9f 00 00 cmpw cr7,r31,r0
ffc12eec: 41 9e 00 38 beq- cr7,ffc12f24 <imfs_dir_rmnod+0x68>
/*
* You cannot remove a mountpoint.
*/
if ( the_jnode->info.directory.mt_fs != NULL )
ffc12ef0: 80 1f 00 5c lwz r0,92(r31)
ffc12ef4: 2f 80 00 00 cmpwi cr7,r0,0
ffc12ef8: 40 9e 00 2c bne- cr7,ffc12f24 <imfs_dir_rmnod+0x68> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EBUSY );
IMFS_create_orphan( the_jnode );
ffc12efc: 7f e3 fb 78 mr r3,r31
ffc12f00: 4b ff c1 3d bl ffc0f03c <IMFS_create_orphan>
IMFS_check_node_remove( the_jnode );
ffc12f04: 7f e3 fb 78 mr r3,r31
ffc12f08: 4b ff c1 95 bl ffc0f09c <IMFS_check_node_remove>
return 0;
ffc12f0c: 38 60 00 00 li r3,0
}
ffc12f10: 80 01 00 14 lwz r0,20(r1)
ffc12f14: 83 e1 00 0c lwz r31,12(r1)
ffc12f18: 38 21 00 10 addi r1,r1,16
ffc12f1c: 7c 08 03 a6 mtlr r0
ffc12f20: 4e 80 00 20 blr
/*
* You cannot remove a mountpoint.
*/
if ( the_jnode->info.directory.mt_fs != NULL )
rtems_set_errno_and_return_minus_one( EBUSY );
ffc12f24: 48 00 0e 69 bl ffc13d8c <__errno>
ffc12f28: 38 00 00 10 li r0,16
ffc12f2c: 90 03 00 00 stw r0,0(r3)
ffc12f30: 38 60 ff ff li r3,-1
IMFS_create_orphan( the_jnode );
IMFS_check_node_remove( the_jnode );
return 0;
}
ffc12f34: 80 01 00 14 lwz r0,20(r1)
ffc12f38: 83 e1 00 0c lwz r31,12(r1)
ffc12f3c: 38 21 00 10 addi r1,r1,16
ffc12f40: 7c 08 03 a6 mtlr r0
ffc12f44: 4e 80 00 20 blr
/*
* You cannot remove a node that still has children
*/
if ( ! rtems_chain_is_empty( &the_jnode->info.directory.Entries ) )
rtems_set_errno_and_return_minus_one( ENOTEMPTY );
ffc12f48: 48 00 0e 45 bl ffc13d8c <__errno>
ffc12f4c: 38 00 00 5a li r0,90
ffc12f50: 90 03 00 00 stw r0,0(r3)
ffc12f54: 38 60 ff ff li r3,-1
ffc12f58: 4b ff ff b8 b ffc12f10 <imfs_dir_rmnod+0x54>
ffc05a20 <init_etc_passwd_group>:
/*
* Initialize useable but dummy databases
*/
void init_etc_passwd_group(void)
{
ffc05a20: 94 21 ff f0 stwu r1,-16(r1)
ffc05a24: 7c 08 02 a6 mflr r0
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
ffc05a28: 3d 20 00 00 lis r9,0
/*
* Initialize useable but dummy databases
*/
void init_etc_passwd_group(void)
{
ffc05a2c: 90 01 00 14 stw r0,20(r1)
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
ffc05a30: 88 09 28 d0 lbz r0,10448(r9)
/*
* Initialize useable but dummy databases
*/
void init_etc_passwd_group(void)
{
ffc05a34: 93 c1 00 08 stw r30,8(r1)
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
ffc05a38: 2f 80 00 00 cmpwi cr7,r0,0
/*
* Initialize useable but dummy databases
*/
void init_etc_passwd_group(void)
{
ffc05a3c: 93 e1 00 0c stw r31,12(r1)
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
ffc05a40: 41 9e 00 1c beq- cr7,ffc05a5c <init_etc_passwd_group+0x3c>
fprintf( fp, "root:x:0:root\n"
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
}
}
ffc05a44: 80 01 00 14 lwz r0,20(r1)
ffc05a48: 83 c1 00 08 lwz r30,8(r1)
ffc05a4c: 7c 08 03 a6 mtlr r0
ffc05a50: 83 e1 00 0c lwz r31,12(r1)
ffc05a54: 38 21 00 10 addi r1,r1,16
ffc05a58: 4e 80 00 20 blr
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
return;
etc_passwd_initted = 1;
mkdir("/etc", 0777);
ffc05a5c: 3c 60 ff c2 lis r3,-62
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
ffc05a60: 3f c0 ff c2 lis r30,-62
ffc05a64: 3f e0 ff c2 lis r31,-62
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
return;
etc_passwd_initted = 1;
ffc05a68: 38 00 00 01 li r0,1
mkdir("/etc", 0777);
ffc05a6c: 38 80 01 ff li r4,511
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
return;
etc_passwd_initted = 1;
ffc05a70: 98 09 28 d0 stb r0,10448(r9)
mkdir("/etc", 0777);
ffc05a74: 38 63 c5 b4 addi r3,r3,-14924
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
ffc05a78: 3b de c5 bc addi r30,r30,-14916
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
return;
etc_passwd_initted = 1;
mkdir("/etc", 0777);
ffc05a7c: 48 00 0b ad bl ffc06628 <mkdir>
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
ffc05a80: 3b ff c5 c8 addi r31,r31,-14904
ffc05a84: 7f c3 f3 78 mr r3,r30
ffc05a88: 7f e4 fb 78 mr r4,r31
ffc05a8c: 48 00 fb 8d bl ffc15618 <fopen>
ffc05a90: 2f 83 00 00 cmpwi cr7,r3,0
ffc05a94: 41 9e 00 7c beq- cr7,ffc05b10 <init_etc_passwd_group+0xf0>
}
else if ((fp = fopen("/etc/passwd", "w")) != NULL) {
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
ffc05a98: 48 00 f1 d9 bl ffc14c70 <fclose>
}
/*
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
ffc05a9c: 3f c0 ff c2 lis r30,-62
ffc05aa0: 3b de c6 38 addi r30,r30,-14792
ffc05aa4: 7f c3 f3 78 mr r3,r30
ffc05aa8: 7f e4 fb 78 mr r4,r31
ffc05aac: 48 00 fb 6d bl ffc15618 <fopen>
ffc05ab0: 2f 83 00 00 cmpwi cr7,r3,0
ffc05ab4: 41 9e 00 20 beq- cr7,ffc05ad4 <init_etc_passwd_group+0xb4>
}
else if ((fp = fopen("/etc/group", "w")) != NULL) {
fprintf( fp, "root:x:0:root\n"
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
ffc05ab8: 48 00 f1 b9 bl ffc14c70 <fclose>
}
}
ffc05abc: 80 01 00 14 lwz r0,20(r1)
ffc05ac0: 83 c1 00 08 lwz r30,8(r1)
ffc05ac4: 7c 08 03 a6 mtlr r0
ffc05ac8: 83 e1 00 0c lwz r31,12(r1)
ffc05acc: 38 21 00 10 addi r1,r1,16
ffc05ad0: 4e 80 00 20 blr
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
fclose(fp);
}
else if ((fp = fopen("/etc/group", "w")) != NULL) {
ffc05ad4: 3c 80 ff c2 lis r4,-62
ffc05ad8: 7f c3 f3 78 mr r3,r30
ffc05adc: 38 84 c5 cc addi r4,r4,-14900
ffc05ae0: 48 00 fb 39 bl ffc15618 <fopen>
ffc05ae4: 7c 7f 1b 79 mr. r31,r3
ffc05ae8: 41 a2 ff 5c beq- ffc05a44 <init_etc_passwd_group+0x24> <== NEVER TAKEN
fprintf( fp, "root:x:0:root\n"
ffc05aec: 3c 60 ff c2 lis r3,-62
ffc05af0: 38 80 00 01 li r4,1
ffc05af4: 38 a0 00 2a li r5,42
ffc05af8: 7f e6 fb 78 mr r6,r31
ffc05afc: 38 63 c6 44 addi r3,r3,-14780
ffc05b00: 48 01 03 d5 bl ffc15ed4 <fwrite>
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
ffc05b04: 7f e3 fb 78 mr r3,r31
ffc05b08: 48 00 f1 69 bl ffc14c70 <fclose>
ffc05b0c: 4b ff ff b0 b ffc05abc <init_etc_passwd_group+0x9c>
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
fclose(fp);
}
else if ((fp = fopen("/etc/passwd", "w")) != NULL) {
ffc05b10: 3c 80 ff c2 lis r4,-62
ffc05b14: 7f c3 f3 78 mr r3,r30
ffc05b18: 38 84 c5 cc addi r4,r4,-14900
ffc05b1c: 48 00 fa fd bl ffc15618 <fopen>
ffc05b20: 7c 7e 1b 79 mr. r30,r3
ffc05b24: 41 a2 ff 78 beq- ffc05a9c <init_etc_passwd_group+0x7c> <== NEVER TAKEN
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
ffc05b28: 3c 60 ff c2 lis r3,-62
ffc05b2c: 38 63 c5 d0 addi r3,r3,-14896
ffc05b30: 38 80 00 01 li r4,1
ffc05b34: 38 a0 00 66 li r5,102
ffc05b38: 7f c6 f3 78 mr r6,r30
ffc05b3c: 48 01 03 99 bl ffc15ed4 <fwrite>
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
ffc05b40: 7f c3 f3 78 mr r3,r30
ffc05b44: 4b ff ff 54 b ffc05a98 <init_etc_passwd_group+0x78>
ffc0777c <iproc>:
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
ffc0777c: 94 21 ff f0 stwu r1,-16(r1)
ffc07780: 7c 08 02 a6 mflr r0
ffc07784: 90 01 00 14 stw r0,20(r1)
if (tty->termios.c_iflag & ISTRIP)
ffc07788: 80 04 00 30 lwz r0,48(r4)
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
ffc0778c: 93 c1 00 08 stw r30,8(r1)
ffc07790: 7c 9e 23 78 mr r30,r4
if (tty->termios.c_iflag & ISTRIP)
ffc07794: 70 09 00 20 andi. r9,r0,32
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
ffc07798: 93 e1 00 0c stw r31,12(r1)
ffc0779c: 7c 7f 1b 78 mr r31,r3
if (tty->termios.c_iflag & ISTRIP)
ffc077a0: 41 82 00 08 beq- ffc077a8 <iproc+0x2c> <== ALWAYS TAKEN
c &= 0x7f;
ffc077a4: 54 7f 06 7e clrlwi r31,r3,25 <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
ffc077a8: 70 0b 02 00 andi. r11,r0,512
ffc077ac: 41 82 00 28 beq- ffc077d4 <iproc+0x58>
c = tolower (c);
ffc077b0: 3d 20 00 00 lis r9,0
ffc077b4: 81 69 27 84 lwz r11,10116(r9)
ffc077b8: 7f e9 fb 78 mr r9,r31
ffc077bc: 7f eb fa 14 add r31,r11,r31
ffc077c0: 89 7f 00 01 lbz r11,1(r31)
ffc077c4: 55 6b 07 be clrlwi r11,r11,30
ffc077c8: 2f 8b 00 01 cmpwi cr7,r11,1
ffc077cc: 41 9e 01 14 beq- cr7,ffc078e0 <iproc+0x164>
ffc077d0: 55 3f 06 3e clrlwi r31,r9,24
if (c == '\r') {
ffc077d4: 2f 9f 00 0d cmpwi cr7,r31,13
ffc077d8: 41 9e 00 68 beq- cr7,ffc07840 <iproc+0xc4>
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
ffc077dc: 2f 9f 00 0a cmpwi cr7,r31,10
ffc077e0: 41 9e 00 f0 beq- cr7,ffc078d0 <iproc+0x154>
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
ffc077e4: 2f 9f 00 00 cmpwi cr7,r31,0
ffc077e8: 40 9e 00 70 bne- cr7,ffc07858 <iproc+0xdc> <== ALWAYS TAKEN
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
ffc077ec: 3d 20 00 00 lis r9,0
ffc077f0: 81 69 21 b8 lwz r11,8632(r9)
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return 0;
ffc077f4: 38 60 00 00 li r3,0
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
ffc077f8: 81 3e 00 20 lwz r9,32(r30)
ffc077fc: 38 0b ff ff addi r0,r11,-1
ffc07800: 7f 89 00 00 cmpw cr7,r9,r0
ffc07804: 40 9c 00 24 bge- cr7,ffc07828 <iproc+0xac> <== NEVER TAKEN
if (tty->termios.c_lflag & ECHO)
ffc07808: 80 1e 00 3c lwz r0,60(r30)
ffc0780c: 70 0b 00 08 andi. r11,r0,8
ffc07810: 40 82 00 d8 bne- ffc078e8 <iproc+0x16c> <== ALWAYS TAKEN
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
ffc07814: 81 7e 00 1c lwz r11,28(r30)
ffc07818: 38 09 00 01 addi r0,r9,1
}
return 0;
ffc0781c: 38 60 00 00 li r3,0
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
ffc07820: 7f eb 49 ae stbx r31,r11,r9
ffc07824: 90 1e 00 20 stw r0,32(r30)
}
return 0;
}
ffc07828: 80 01 00 14 lwz r0,20(r1)
ffc0782c: 83 c1 00 08 lwz r30,8(r1)
ffc07830: 7c 08 03 a6 mtlr r0
ffc07834: 83 e1 00 0c lwz r31,12(r1)
ffc07838: 38 21 00 10 addi r1,r1,16
ffc0783c: 4e 80 00 20 blr
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
ffc07840: 70 09 00 80 andi. r9,r0,128
return 0;
ffc07844: 38 60 00 00 li r3,0
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
ffc07848: 40 a2 ff e0 bne- ffc07828 <iproc+0xac> <== NEVER TAKEN
return 0;
if (tty->termios.c_iflag & ICRNL)
ffc0784c: 70 0b 01 00 andi. r11,r0,256
ffc07850: 41 82 00 08 beq- ffc07858 <iproc+0xdc> <== NEVER TAKEN
c = '\n';
ffc07854: 3b e0 00 0a li r31,10
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
ffc07858: 80 1e 00 3c lwz r0,60(r30)
ffc0785c: 70 0b 00 02 andi. r11,r0,2
ffc07860: 41 a2 ff 8c beq- ffc077ec <iproc+0x70>
if (c == tty->termios.c_cc[VERASE]) {
ffc07864: 89 3e 00 43 lbz r9,67(r30)
ffc07868: 7f 89 f8 00 cmpw cr7,r9,r31
ffc0786c: 41 9e 00 e8 beq- cr7,ffc07954 <iproc+0x1d8>
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
ffc07870: 89 3e 00 44 lbz r9,68(r30)
ffc07874: 7f 89 f8 00 cmpw cr7,r9,r31
ffc07878: 41 9e 00 94 beq- cr7,ffc0790c <iproc+0x190>
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
ffc0787c: 89 3e 00 45 lbz r9,69(r30)
return 1;
ffc07880: 38 60 00 01 li r3,1
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
ffc07884: 7f 89 f8 00 cmpw cr7,r9,r31
ffc07888: 41 be ff a0 beq- cr7,ffc07828 <iproc+0xac> <== NEVER TAKEN
return 1;
} else if (c == '\n') {
ffc0788c: 2f 9f 00 0a cmpwi cr7,r31,10
ffc07890: 41 9e 00 90 beq- cr7,ffc07920 <iproc+0x1a4>
if (tty->termios.c_lflag & (ECHO | ECHONL))
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
ffc07894: 89 3e 00 4c lbz r9,76(r30)
ffc07898: 7f 89 f8 00 cmpw cr7,r9,r31
ffc0789c: 41 9e 00 10 beq- cr7,ffc078ac <iproc+0x130> <== NEVER TAKEN
ffc078a0: 89 3e 00 51 lbz r9,81(r30)
ffc078a4: 7f 89 f8 00 cmpw cr7,r9,r31
ffc078a8: 40 9e ff 44 bne+ cr7,ffc077ec <iproc+0x70> <== ALWAYS TAKEN
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
ffc078ac: 70 0b 00 08 andi. r11,r0,8 <== NOT EXECUTED
ffc078b0: 40 82 00 4c bne- ffc078fc <iproc+0x180> <== NOT EXECUTED
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
ffc078b4: 81 3e 00 20 lwz r9,32(r30) <== NOT EXECUTED
return 1;
ffc078b8: 38 60 00 01 li r3,1 <== NOT EXECUTED
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
ffc078bc: 81 7e 00 1c lwz r11,28(r30) <== NOT EXECUTED
ffc078c0: 38 09 00 01 addi r0,r9,1 <== NOT EXECUTED
ffc078c4: 7f eb 49 ae stbx r31,r11,r9 <== NOT EXECUTED
ffc078c8: 90 1e 00 20 stw r0,32(r30) <== NOT EXECUTED
return 1;
ffc078cc: 4b ff ff 5c b ffc07828 <iproc+0xac> <== NOT EXECUTED
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
ffc078d0: 70 09 00 40 andi. r9,r0,64
ffc078d4: 41 a2 ff 84 beq- ffc07858 <iproc+0xdc> <== ALWAYS TAKEN
c = '\r';
ffc078d8: 3b e0 00 0d li r31,13 <== NOT EXECUTED
ffc078dc: 4b ff ff 7c b ffc07858 <iproc+0xdc> <== NOT EXECUTED
{
if (tty->termios.c_iflag & ISTRIP)
c &= 0x7f;
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
ffc078e0: 39 29 00 20 addi r9,r9,32
ffc078e4: 4b ff fe ec b ffc077d0 <iproc+0x54>
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
ffc078e8: 7f e3 fb 78 mr r3,r31
ffc078ec: 7f c4 f3 78 mr r4,r30
ffc078f0: 4b ff fb 4d bl ffc0743c <echo>
ffc078f4: 81 3e 00 20 lwz r9,32(r30)
ffc078f8: 4b ff ff 1c b ffc07814 <iproc+0x98>
tty->cbuf[tty->ccount++] = c;
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
ffc078fc: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc07900: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc07904: 4b ff fb 39 bl ffc0743c <echo> <== NOT EXECUTED
ffc07908: 4b ff ff ac b ffc078b4 <iproc+0x138> <== NOT EXECUTED
if (c == tty->termios.c_cc[VERASE]) {
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
ffc0790c: 7f c3 f3 78 mr r3,r30
ffc07910: 38 80 00 01 li r4,1
ffc07914: 4b ff fb cd bl ffc074e0 <erase>
return 0;
ffc07918: 38 60 00 00 li r3,0
ffc0791c: 4b ff ff 0c b ffc07828 <iproc+0xac>
}
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
} else if (c == '\n') {
if (tty->termios.c_lflag & (ECHO | ECHONL))
ffc07920: 70 09 00 48 andi. r9,r0,72
ffc07924: 41 a2 00 10 beq+ ffc07934 <iproc+0x1b8> <== NEVER TAKEN
echo (c, tty);
ffc07928: 38 60 00 0a li r3,10
ffc0792c: 7f c4 f3 78 mr r4,r30
ffc07930: 4b ff fb 0d bl ffc0743c <echo>
tty->cbuf[tty->ccount++] = c;
ffc07934: 81 3e 00 20 lwz r9,32(r30)
ffc07938: 39 40 00 0a li r10,10
ffc0793c: 81 7e 00 1c lwz r11,28(r30)
return 1;
ffc07940: 38 60 00 01 li r3,1
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
} else if (c == '\n') {
if (tty->termios.c_lflag & (ECHO | ECHONL))
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
ffc07944: 38 09 00 01 addi r0,r9,1
ffc07948: 7d 4b 49 ae stbx r10,r11,r9
ffc0794c: 90 1e 00 20 stw r0,32(r30)
return 1;
ffc07950: 4b ff fe d8 b ffc07828 <iproc+0xac>
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
if (c == tty->termios.c_cc[VERASE]) {
erase (tty, 0);
ffc07954: 7f c3 f3 78 mr r3,r30
ffc07958: 38 80 00 00 li r4,0
ffc0795c: 4b ff fb 85 bl ffc074e0 <erase>
return 0;
ffc07960: 38 60 00 00 li r3,0
ffc07964: 4b ff fe c4 b ffc07828 <iproc+0xac>
ffc1ef60 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
ffc1ef60: 94 21 ff d0 stwu r1,-48(r1)
ffc1ef64: 7c 08 02 a6 mflr r0
ffc1ef68: 93 61 00 1c stw r27,28(r1)
ffc1ef6c: 7c bb 2b 78 mr r27,r5
ffc1ef70: 93 81 00 20 stw r28,32(r1)
ffc1ef74: 7c 9c 23 78 mr r28,r4
ffc1ef78: 93 e1 00 2c stw r31,44(r1)
ffc1ef7c: 7c 7f 1b 78 mr r31,r3
ffc1ef80: 90 01 00 34 stw r0,52(r1)
ffc1ef84: 93 41 00 18 stw r26,24(r1)
ffc1ef88: 93 a1 00 24 stw r29,36(r1)
ffc1ef8c: 93 c1 00 28 stw r30,40(r1)
POSIX_signals_Siginfo_node *psiginfo;
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
ffc1ef90: 4b ff fa 2d bl ffc1e9bc <getpid>
ffc1ef94: 7f 83 f8 00 cmpw cr7,r3,r31
ffc1ef98: 40 9e 02 98 bne- cr7,ffc1f230 <killinfo+0x2d0>
rtems_set_errno_and_return_minus_one( ESRCH );
/*
* Validate the signal passed.
*/
if ( !sig )
ffc1ef9c: 2f 9c 00 00 cmpwi cr7,r28,0
ffc1efa0: 41 9e 02 a4 beq- cr7,ffc1f244 <killinfo+0x2e4>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
ffc1efa4: 3b fc ff ff addi r31,r28,-1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
ffc1efa8: 2b 9f 00 1f cmplwi cr7,r31,31
ffc1efac: 41 9d 02 98 bgt- cr7,ffc1f244 <killinfo+0x2e4>
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 )
ffc1efb0: 1f dc 00 0c mulli r30,r28,12
ffc1efb4: 3f a0 00 00 lis r29,0
ffc1efb8: 3b bd 31 c0 addi r29,r29,12736
ffc1efbc: 7d 3d f2 14 add r9,r29,r30
ffc1efc0: 80 09 00 08 lwz r0,8(r9)
return 0;
ffc1efc4: 38 60 00 00 li r3,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 )
ffc1efc8: 2f 80 00 01 cmpwi cr7,r0,1
ffc1efcc: 41 9e 01 a8 beq- cr7,ffc1f174 <killinfo+0x214>
/*
* 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 ) )
ffc1efd0: 2f 9c 00 08 cmpwi cr7,r28,8
ffc1efd4: 41 9e 01 c8 beq- cr7,ffc1f19c <killinfo+0x23c>
ffc1efd8: 2f 9c 00 04 cmpwi cr7,r28,4
ffc1efdc: 41 9e 01 c0 beq- cr7,ffc1f19c <killinfo+0x23c>
ffc1efe0: 2f 9c 00 0b cmpwi cr7,r28,11
ffc1efe4: 41 9e 01 b8 beq- cr7,ffc1f19c <killinfo+0x23c>
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
siginfo->si_code = SI_USER;
if ( !value ) {
ffc1efe8: 2f 9b 00 00 cmpwi cr7,r27,0
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
ffc1efec: 93 81 00 08 stw r28,8(r1)
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
ffc1eff0: 38 00 00 01 li r0,1
ffc1eff4: 7c 1f f8 30 slw r31,r0,r31
siginfo->si_code = SI_USER;
ffc1eff8: 90 01 00 0c stw r0,12(r1)
if ( !value ) {
ffc1effc: 41 9e 02 18 beq- cr7,ffc1f214 <killinfo+0x2b4>
siginfo->si_value.sival_int = 0;
} else {
siginfo->si_value = *value;
ffc1f000: 80 1b 00 00 lwz r0,0(r27)
ffc1f004: 90 01 00 10 stw r0,16(r1)
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc1f008: 3d 20 00 00 lis r9,0
ffc1f00c: 81 69 28 0c lwz r11,10252(r9)
ffc1f010: 38 0b 00 01 addi r0,r11,1
ffc1f014: 90 09 28 0c stw r0,10252(r9)
return _Thread_Dispatch_disable_level;
ffc1f018: 80 09 28 0c lwz r0,10252(r9)
/*
* 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;
ffc1f01c: 3d 20 00 00 lis r9,0
ffc1f020: 80 69 31 50 lwz r3,12624(r9)
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
ffc1f024: 81 23 01 34 lwz r9,308(r3)
ffc1f028: 80 09 00 d0 lwz r0,208(r9)
ffc1f02c: 7f e6 00 79 andc. r6,r31,r0
ffc1f030: 40 82 01 14 bne- ffc1f144 <killinfo+0x1e4>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc1f034: 3d 20 00 00 lis r9,0
ffc1f038: 39 69 33 4c addi r11,r9,13132
ffc1f03c: 80 69 33 4c lwz r3,13132(r9)
/* 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 );
ffc1f040: 39 6b 00 04 addi r11,r11,4
ffc1f044: 7f 83 58 00 cmpw cr7,r3,r11
ffc1f048: 41 9e 00 4c beq- cr7,ffc1f094 <killinfo+0x134>
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
ffc1f04c: 80 03 00 30 lwz r0,48(r3)
for ( the_node = _Chain_First( the_chain );
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
ffc1f050: 81 23 01 34 lwz r9,308(r3)
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
ffc1f054: 7f ea 00 39 and. r10,r31,r0
ffc1f058: 40 82 00 ec bne- ffc1f144 <killinfo+0x1e4>
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
ffc1f05c: 80 09 00 d0 lwz r0,208(r9)
ffc1f060: 7f fa 00 79 andc. r26,r31,r0
ffc1f064: 41 a2 00 24 beq+ ffc1f088 <killinfo+0x128>
ffc1f068: 48 00 00 dc b ffc1f144 <killinfo+0x1e4>
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
ffc1f06c: 80 03 00 30 lwz r0,48(r3) <== NOT EXECUTED
for ( the_node = _Chain_First( the_chain );
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
ffc1f070: 81 23 01 34 lwz r9,308(r3) <== NOT EXECUTED
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
ffc1f074: 7f fb 00 39 and. r27,r31,r0 <== NOT EXECUTED
ffc1f078: 40 82 00 cc bne- ffc1f144 <killinfo+0x1e4> <== NOT EXECUTED
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
ffc1f07c: 80 09 00 d0 lwz r0,208(r9) <== NOT EXECUTED
ffc1f080: 7f e6 00 79 andc. r6,r31,r0 <== NOT EXECUTED
ffc1f084: 40 82 00 c0 bne- ffc1f144 <killinfo+0x1e4> <== NOT EXECUTED
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = _Chain_First( the_chain );
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
ffc1f088: 80 63 00 00 lwz r3,0(r3)
/* XXX violation of visibility -- need to define thread queue support */
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = _Chain_First( the_chain );
ffc1f08c: 7f 83 58 00 cmpw cr7,r3,r11
ffc1f090: 40 9e ff dc bne+ cr7,ffc1f06c <killinfo+0x10c> <== NEVER TAKEN
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
ffc1f094: 3d 20 00 00 lis r9,0
ffc1f098: 88 e9 27 24 lbz r7,10020(r9)
ffc1f09c: 3c a0 00 00 lis r5,0
ffc1f0a0: 38 a5 2c 64 addi r5,r5,11364
ffc1f0a4: 38 e7 00 01 addi r7,r7,1
*/
#define _POSIX_signals_Is_interested( _api, _mask ) \
( ~(_api)->signals_blocked & (_mask) )
int killinfo(
ffc1f0a8: 38 85 00 08 addi r4,r5,8
*
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
ffc1f0ac: 38 60 00 00 li r3,0
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
/*
* This can occur when no one is interested and an API is not configured.
*/
if ( !_Objects_Information_table[ the_api ] )
ffc1f0b0: 85 25 00 04 lwzu r9,4(r5)
ffc1f0b4: 2f 89 00 00 cmpwi cr7,r9,0
ffc1f0b8: 41 9e 00 7c beq- cr7,ffc1f134 <killinfo+0x1d4> <== NEVER TAKEN
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
ffc1f0bc: 81 29 00 04 lwz r9,4(r9)
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
ffc1f0c0: a1 09 00 10 lhz r8,16(r9)
object_table = the_info->local_table;
ffc1f0c4: 81 49 00 1c lwz r10,28(r9)
for ( index = 1 ; index <= maximum ; index++ ) {
ffc1f0c8: 2f 88 00 00 cmpwi cr7,r8,0
ffc1f0cc: 41 9e 00 68 beq- cr7,ffc1f134 <killinfo+0x1d4>
ffc1f0d0: 39 60 00 01 li r11,1
the_thread = (Thread_Control *) object_table[ index ];
ffc1f0d4: 85 2a 00 04 lwzu r9,4(r10)
if ( !the_thread )
ffc1f0d8: 2f 89 00 00 cmpwi cr7,r9,0
ffc1f0dc: 41 9e 00 4c beq- cr7,ffc1f128 <killinfo+0x1c8>
/*
* If this thread is of lower priority than the interested thread,
* go on to the next thread.
*/
if ( the_thread->current_priority > interested_priority )
ffc1f0e0: 80 09 00 14 lwz r0,20(r9)
ffc1f0e4: 7f 80 38 40 cmplw cr7,r0,r7
ffc1f0e8: 41 9d 00 40 bgt- cr7,ffc1f128 <killinfo+0x1c8>
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
ffc1f0ec: 80 c9 01 34 lwz r6,308(r9)
ffc1f0f0: 80 c6 00 d0 lwz r6,208(r6)
ffc1f0f4: 7f fa 30 79 andc. r26,r31,r6
ffc1f0f8: 41 82 00 30 beq- ffc1f128 <killinfo+0x1c8>
*
* 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 ) {
ffc1f0fc: 41 9c 00 24 blt- cr7,ffc1f120 <killinfo+0x1c0>
* and blocking interruptibutable by signal.
*
* If the interested thread is ready, don't think about changing.
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
ffc1f100: 2f 83 00 00 cmpwi cr7,r3,0
ffc1f104: 41 9e 00 24 beq- cr7,ffc1f128 <killinfo+0x1c8> <== NEVER TAKEN
ffc1f108: 80 c3 00 10 lwz r6,16(r3)
ffc1f10c: 2f 86 00 00 cmpwi cr7,r6,0
ffc1f110: 41 9e 00 18 beq- cr7,ffc1f128 <killinfo+0x1c8> <== NEVER TAKEN
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
ffc1f114: 83 69 00 10 lwz r27,16(r9)
ffc1f118: 2f 9b 00 00 cmpwi cr7,r27,0
ffc1f11c: 40 9e 01 00 bne- cr7,ffc1f21c <killinfo+0x2bc>
ffc1f120: 7c 07 03 78 mr r7,r0
ffc1f124: 7d 23 4b 78 mr r3,r9
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
ffc1f128: 39 6b 00 01 addi r11,r11,1
ffc1f12c: 7f 88 58 40 cmplw cr7,r8,r11
ffc1f130: 40 9c ff a4 bge+ cr7,ffc1f0d4 <killinfo+0x174>
* + 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++) {
ffc1f134: 7f 85 20 00 cmpw cr7,r5,r4
ffc1f138: 40 be ff 78 bne- cr7,ffc1f0b0 <killinfo+0x150>
}
}
}
}
if ( interested ) {
ffc1f13c: 2f 83 00 00 cmpwi cr7,r3,0
ffc1f140: 41 9e 00 18 beq- cr7,ffc1f158 <killinfo+0x1f8>
/*
* 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 ) ) {
ffc1f144: 7f 84 e3 78 mr r4,r28
ffc1f148: 38 a1 00 08 addi r5,r1,8
ffc1f14c: 48 00 01 4d bl ffc1f298 <_POSIX_signals_Unblock_thread>
ffc1f150: 2f 83 00 00 cmpwi cr7,r3,0
ffc1f154: 40 9e 00 18 bne- cr7,ffc1f16c <killinfo+0x20c>
/*
* 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 );
ffc1f158: 7f e3 fb 78 mr r3,r31
ffc1f15c: 48 00 01 15 bl ffc1f270 <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
ffc1f160: 7c 1d f0 2e lwzx r0,r29,r30
ffc1f164: 2f 80 00 02 cmpwi cr7,r0,2
ffc1f168: 41 9e 00 68 beq- cr7,ffc1f1d0 <killinfo+0x270>
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
ffc1f16c: 4b fe d3 7d bl ffc0c4e8 <_Thread_Enable_dispatch>
return 0;
ffc1f170: 38 60 00 00 li r3,0
}
ffc1f174: 80 01 00 34 lwz r0,52(r1)
ffc1f178: 83 41 00 18 lwz r26,24(r1)
ffc1f17c: 7c 08 03 a6 mtlr r0
ffc1f180: 83 61 00 1c lwz r27,28(r1)
ffc1f184: 83 81 00 20 lwz r28,32(r1)
ffc1f188: 83 a1 00 24 lwz r29,36(r1)
ffc1f18c: 83 c1 00 28 lwz r30,40(r1)
ffc1f190: 83 e1 00 2c lwz r31,44(r1)
ffc1f194: 38 21 00 30 addi r1,r1,48
ffc1f198: 4e 80 00 20 blr
* P1003.1c/Draft 10, p. 33 says that certain signals should always
* be directed to the executing thread such as those caused by hardware
* faults.
*/
if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) )
return pthread_kill( pthread_self(), sig );
ffc1f19c: 48 00 03 69 bl ffc1f504 <pthread_self>
ffc1f1a0: 7f 84 e3 78 mr r4,r28
ffc1f1a4: 48 00 02 61 bl ffc1f404 <pthread_kill>
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
ffc1f1a8: 80 01 00 34 lwz r0,52(r1)
ffc1f1ac: 83 41 00 18 lwz r26,24(r1)
ffc1f1b0: 7c 08 03 a6 mtlr r0
ffc1f1b4: 83 61 00 1c lwz r27,28(r1)
ffc1f1b8: 83 81 00 20 lwz r28,32(r1)
ffc1f1bc: 83 a1 00 24 lwz r29,36(r1)
ffc1f1c0: 83 c1 00 28 lwz r30,40(r1)
ffc1f1c4: 83 e1 00 2c lwz r31,44(r1)
ffc1f1c8: 38 21 00 30 addi r1,r1,48
ffc1f1cc: 4e 80 00 20 blr
*/
_POSIX_signals_Set_process_signals( mask );
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
psiginfo = (POSIX_signals_Siginfo_node *)
ffc1f1d0: 3c 60 00 00 lis r3,0
ffc1f1d4: 38 63 33 40 addi r3,r3,13120
ffc1f1d8: 4b fe b0 6d bl ffc0a244 <_Chain_Get>
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
if ( !psiginfo ) {
ffc1f1dc: 7c 69 1b 79 mr. r9,r3
ffc1f1e0: 41 82 00 78 beq- ffc1f258 <killinfo+0x2f8>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
ffc1f1e4: 80 01 00 08 lwz r0,8(r1)
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
ffc1f1e8: 3c 60 00 00 lis r3,0
ffc1f1ec: 38 63 33 b4 addi r3,r3,13236
if ( !psiginfo ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
ffc1f1f0: 90 09 00 08 stw r0,8(r9)
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
ffc1f1f4: 7c 63 f2 14 add r3,r3,r30
ffc1f1f8: 7d 24 4b 78 mr r4,r9
if ( !psiginfo ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
ffc1f1fc: 80 01 00 0c lwz r0,12(r1)
ffc1f200: 90 09 00 0c stw r0,12(r9)
ffc1f204: 80 01 00 10 lwz r0,16(r1)
ffc1f208: 90 09 00 10 stw r0,16(r9)
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
ffc1f20c: 4b fe af e1 bl ffc0a1ec <_Chain_Append>
ffc1f210: 4b ff ff 5c b ffc1f16c <killinfo+0x20c>
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
siginfo->si_code = SI_USER;
if ( !value ) {
siginfo->si_value.sival_int = 0;
ffc1f214: 93 61 00 10 stw r27,16(r1)
ffc1f218: 4b ff fd f0 b ffc1f008 <killinfo+0xa8>
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
ffc1f21c: 74 da 10 00 andis. r26,r6,4096
ffc1f220: 40 a2 ff 08 bne- ffc1f128 <killinfo+0x1c8>
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
ffc1f224: 77 66 10 00 andis. r6,r27,4096
ffc1f228: 41 a2 ff 00 beq- ffc1f128 <killinfo+0x1c8>
ffc1f22c: 4b ff fe f4 b ffc1f120 <killinfo+0x1c0>
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
rtems_set_errno_and_return_minus_one( ESRCH );
ffc1f230: 4b ff 4b 5d bl ffc13d8c <__errno>
ffc1f234: 38 00 00 03 li r0,3
ffc1f238: 90 03 00 00 stw r0,0(r3)
ffc1f23c: 38 60 ff ff li r3,-1
ffc1f240: 4b ff ff 34 b ffc1f174 <killinfo+0x214>
*/
if ( !sig )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
rtems_set_errno_and_return_minus_one( EINVAL );
ffc1f244: 4b ff 4b 49 bl ffc13d8c <__errno>
ffc1f248: 38 00 00 16 li r0,22
ffc1f24c: 90 03 00 00 stw r0,0(r3)
ffc1f250: 38 60 ff ff li r3,-1
ffc1f254: 4b ff ff 20 b ffc1f174 <killinfo+0x214>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
if ( !psiginfo ) {
_Thread_Enable_dispatch();
ffc1f258: 4b fe d2 91 bl ffc0c4e8 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
ffc1f25c: 4b ff 4b 31 bl ffc13d8c <__errno>
ffc1f260: 38 00 00 0b li r0,11
ffc1f264: 90 03 00 00 stw r0,0(r3)
ffc1f268: 38 60 ff ff li r3,-1
ffc1f26c: 4b ff ff 08 b ffc1f174 <killinfo+0x214>
ffc05c70 <libc_wrapup>:
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
ffc05c70: 94 21 ff f0 stwu r1,-16(r1)
ffc05c74: 7c 08 02 a6 mflr r0
/*
* In case RTEMS is already down, don't do this. It could be
* dangerous.
*/
if (!_System_state_Is_up(_System_state_Get()))
ffc05c78: 3d 20 00 00 lis r9,0
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
ffc05c7c: 90 01 00 14 stw r0,20(r1)
/*
* In case RTEMS is already down, don't do this. It could be
* dangerous.
*/
if (!_System_state_Is_up(_System_state_Get()))
ffc05c80: 80 09 28 48 lwz r0,10312(r9)
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
ffc05c84: 93 c1 00 08 stw r30,8(r1)
/*
* In case RTEMS is already down, don't do this. It could be
* dangerous.
*/
if (!_System_state_Is_up(_System_state_Get()))
ffc05c88: 2f 80 00 03 cmpwi cr7,r0,3
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
ffc05c8c: 93 e1 00 0c stw r31,12(r1)
/*
* In case RTEMS is already down, don't do this. It could be
* dangerous.
*/
if (!_System_state_Is_up(_System_state_Get()))
ffc05c90: 41 9e 00 1c beq- cr7,ffc05cac <libc_wrapup+0x3c> <== ALWAYS TAKEN
*/
fclose (stdin);
fclose (stdout);
fclose (stderr);
}
ffc05c94: 80 01 00 14 lwz r0,20(r1) <== NOT EXECUTED
ffc05c98: 83 c1 00 08 lwz r30,8(r1) <== NOT EXECUTED
ffc05c9c: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc05ca0: 83 e1 00 0c lwz r31,12(r1) <== NOT EXECUTED
ffc05ca4: 38 21 00 10 addi r1,r1,16 <== NOT EXECUTED
ffc05ca8: 4e 80 00 20 blr <== NOT EXECUTED
/*
* This was already done if the user called exit() directly .
_wrapup_reent(0);
*/
if (_REENT != _global_impure_ptr) {
ffc05cac: 3f e0 00 00 lis r31,0
ffc05cb0: 3d 20 00 00 lis r9,0
ffc05cb4: 80 1f 27 8c lwz r0,10124(r31)
ffc05cb8: 83 c9 27 88 lwz r30,10120(r9)
ffc05cbc: 7f 80 f0 00 cmpw cr7,r0,r30
ffc05cc0: 41 9e 00 10 beq- cr7,ffc05cd0 <libc_wrapup+0x60>
_wrapup_reent(_global_impure_ptr);
ffc05cc4: 7f c3 f3 78 mr r3,r30
ffc05cc8: 48 00 f1 d9 bl ffc14ea0 <_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;
ffc05ccc: 93 df 27 8c stw r30,10124(r31)
*
* Should this be changed to do *all* file streams?
* _fwalk (_REENT, fclose);
*/
fclose (stdin);
ffc05cd0: 80 7e 00 04 lwz r3,4(r30)
ffc05cd4: 48 00 e2 45 bl ffc13f18 <fclose>
fclose (stdout);
ffc05cd8: 81 3f 27 8c lwz r9,10124(r31)
ffc05cdc: 80 69 00 08 lwz r3,8(r9)
ffc05ce0: 48 00 e2 39 bl ffc13f18 <fclose>
fclose (stderr);
ffc05ce4: 81 3f 27 8c lwz r9,10124(r31)
ffc05ce8: 80 69 00 0c lwz r3,12(r9)
ffc05cec: 48 00 e2 2d bl ffc13f18 <fclose>
}
ffc05cf0: 80 01 00 14 lwz r0,20(r1)
ffc05cf4: 83 c1 00 08 lwz r30,8(r1)
ffc05cf8: 7c 08 03 a6 mtlr r0
ffc05cfc: 83 e1 00 0c lwz r31,12(r1)
ffc05d00: 38 21 00 10 addi r1,r1,16
ffc05d04: 4e 80 00 20 blr
ffc055b8 <malloc>:
#include "malloc_p.h"
void *malloc(
size_t size
)
{
ffc055b8: 94 21 ff f0 stwu r1,-16(r1)
ffc055bc: 7c 08 02 a6 mflr r0
void *return_this;
MSBUMP(malloc_calls, 1);
ffc055c0: 3d 20 00 00 lis r9,0
#include "malloc_p.h"
void *malloc(
size_t size
)
{
ffc055c4: 90 01 00 14 stw r0,20(r1)
void *return_this;
MSBUMP(malloc_calls, 1);
ffc055c8: 39 29 2b 60 addi r9,r9,11104
ffc055cc: 81 69 00 04 lwz r11,4(r9)
#include "malloc_p.h"
void *malloc(
size_t size
)
{
ffc055d0: 93 c1 00 08 stw r30,8(r1)
/*
* Validate the parameters
*/
if ( !size )
return (void *) 0;
ffc055d4: 3b c0 00 00 li r30,0
size_t size
)
{
void *return_this;
MSBUMP(malloc_calls, 1);
ffc055d8: 39 6b 00 01 addi r11,r11,1
#include "malloc_p.h"
void *malloc(
size_t size
)
{
ffc055dc: 93 e1 00 0c stw r31,12(r1)
ffc055e0: 7c 7f 1b 78 mr r31,r3
void *return_this;
MSBUMP(malloc_calls, 1);
ffc055e4: 91 69 00 04 stw r11,4(r9)
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
ffc055e8: 4b ff fe 45 bl ffc0542c <malloc_deferred_frees_process>
/*
* Validate the parameters
*/
if ( !size )
ffc055ec: 2f 9f 00 00 cmpwi cr7,r31,0
ffc055f0: 41 9e 00 74 beq- cr7,ffc05664 <malloc+0xac>
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
ffc055f4: 3d 20 00 00 lis r9,0
ffc055f8: 80 09 28 48 lwz r0,10312(r9)
ffc055fc: 2f 80 00 03 cmpwi cr7,r0,3
ffc05600: 41 9e 00 80 beq- cr7,ffc05680 <malloc+0xc8>
RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate(
Heap_Control *heap,
uintptr_t size
)
{
return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
ffc05604: 3d 20 00 00 lis r9,0
ffc05608: 80 69 27 2c lwz r3,10028(r9)
ffc0560c: 7f e4 fb 78 mr r4,r31
ffc05610: 38 a0 00 00 li r5,0
ffc05614: 38 c0 00 00 li r6,0
ffc05618: 48 00 61 79 bl ffc0b790 <_Protected_heap_Allocate_aligned_with_boundary>
* If this fails then return a NULL pointer.
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
ffc0561c: 7c 7e 1b 79 mr. r30,r3
ffc05620: 41 82 00 8c beq- ffc056ac <malloc+0xf4> <== NEVER TAKEN
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
ffc05624: 3d 20 00 00 lis r9,0
ffc05628: 80 09 27 a4 lwz r0,10148(r9)
ffc0562c: 2f 80 00 00 cmpwi cr7,r0,0
ffc05630: 41 9e 00 14 beq- cr7,ffc05644 <malloc+0x8c>
(*rtems_malloc_dirty_helper)( return_this, size );
ffc05634: 7f c3 f3 78 mr r3,r30
ffc05638: 7c 09 03 a6 mtctr r0
ffc0563c: 7f e4 fb 78 mr r4,r31
ffc05640: 4e 80 04 21 bctrl
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
ffc05644: 3d 20 00 00 lis r9,0
ffc05648: 81 29 27 ac lwz r9,10156(r9)
ffc0564c: 2f 89 00 00 cmpwi cr7,r9,0
ffc05650: 41 9e 00 14 beq- cr7,ffc05664 <malloc+0xac>
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
ffc05654: 80 09 00 04 lwz r0,4(r9)
ffc05658: 7f c3 f3 78 mr r3,r30
ffc0565c: 7c 09 03 a6 mtctr r0
ffc05660: 4e 80 04 21 bctrl
return return_this;
}
ffc05664: 80 01 00 14 lwz r0,20(r1)
ffc05668: 7f c3 f3 78 mr r3,r30
ffc0566c: 83 e1 00 0c lwz r31,12(r1)
ffc05670: 7c 08 03 a6 mtlr r0
ffc05674: 83 c1 00 08 lwz r30,8(r1)
ffc05678: 38 21 00 10 addi r1,r1,16
ffc0567c: 4e 80 00 20 blr
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() )
ffc05680: 4b ff fd 65 bl ffc053e4 <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()) &&
ffc05684: 2f 83 00 00 cmpwi cr7,r3,0
ffc05688: 41 be ff dc beq- cr7,ffc05664 <malloc+0xac> <== NEVER TAKEN
ffc0568c: 3d 20 00 00 lis r9,0
ffc05690: 80 69 27 2c lwz r3,10028(r9)
ffc05694: 7f e4 fb 78 mr r4,r31
ffc05698: 38 a0 00 00 li r5,0
ffc0569c: 38 c0 00 00 li r6,0
ffc056a0: 48 00 60 f1 bl ffc0b790 <_Protected_heap_Allocate_aligned_with_boundary>
* If this fails then return a NULL pointer.
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
ffc056a4: 7c 7e 1b 79 mr. r30,r3
ffc056a8: 40 82 ff 7c bne+ ffc05624 <malloc+0x6c>
if (rtems_malloc_sbrk_helpers)
ffc056ac: 3d 20 00 00 lis r9,0
ffc056b0: 81 29 27 a8 lwz r9,10152(r9)
ffc056b4: 2f 89 00 00 cmpwi cr7,r9,0
ffc056b8: 41 9e 00 24 beq- cr7,ffc056dc <malloc+0x124>
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
ffc056bc: 80 09 00 04 lwz r0,4(r9)
ffc056c0: 7f e3 fb 78 mr r3,r31
ffc056c4: 7c 09 03 a6 mtctr r0
ffc056c8: 4e 80 04 21 bctrl
if ( !return_this ) {
ffc056cc: 2c 03 00 00 cmpwi r3,0
ffc056d0: 41 82 00 0c beq- ffc056dc <malloc+0x124> <== ALWAYS TAKEN
ffc056d4: 7c 7e 1b 78 mr r30,r3 <== NOT EXECUTED
ffc056d8: 4b ff ff 4c b ffc05624 <malloc+0x6c> <== NOT EXECUTED
errno = ENOMEM;
ffc056dc: 48 00 e6 b1 bl ffc13d8c <__errno>
ffc056e0: 38 00 00 0c li r0,12
ffc056e4: 90 03 00 00 stw r0,0(r3)
return (void *) 0;
ffc056e8: 4b ff ff 7c b ffc05664 <malloc+0xac>
ffc0530c <malloc_sbrk_extend_and_allocate>:
* 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;
ffc0530c: 3d 20 00 00 lis r9,0
}
void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
ffc05310: 94 21 ff e8 stwu r1,-24(r1)
ffc05314: 7c 08 02 a6 mflr r0
* 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;
ffc05318: 81 29 27 e0 lwz r9,10208(r9)
}
void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
ffc0531c: 93 a1 00 0c stw r29,12(r1)
ffc05320: 7c 7d 1b 78 mr r29,r3
* in "page" amounts.
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
if ( sbrk_amount == 0 )
ffc05324: 2f 89 00 00 cmpwi cr7,r9,0
}
void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
ffc05328: 93 c1 00 10 stw r30,16(r1)
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
if ( sbrk_amount == 0 )
return (void *) 0;
ffc0532c: 3b c0 00 00 li r30,0
}
void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
ffc05330: 90 01 00 1c stw r0,28(r1)
ffc05334: 93 81 00 08 stw r28,8(r1)
ffc05338: 93 e1 00 14 stw r31,20(r1)
* in "page" amounts.
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
if ( sbrk_amount == 0 )
ffc0533c: 41 9e 00 64 beq- cr7,ffc053a0 <malloc_sbrk_extend_and_allocate+0x94><== NEVER TAKEN
return (void *) 0;
the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
ffc05340: 7f e3 4a 14 add r31,r3,r9
ffc05344: 7f ff 4b 96 divwu r31,r31,r9
ffc05348: 7f ff 49 d6 mullw r31,r31,r9
starting_address = (void *) sbrk(the_size);
ffc0534c: 7f e3 fb 78 mr r3,r31
ffc05350: 4b ff b0 a5 bl ffc003f4 <sbrk>
if ( starting_address == (void*) -1 )
ffc05354: 2f 83 ff ff cmpwi cr7,r3,-1
if ( sbrk_amount == 0 )
return (void *) 0;
the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
starting_address = (void *) sbrk(the_size);
ffc05358: 7c 64 1b 78 mr r4,r3
if ( starting_address == (void*) -1 )
ffc0535c: 41 9e 00 44 beq- cr7,ffc053a0 <malloc_sbrk_extend_and_allocate+0x94>
return (void *) 0;
if ( !_Protected_heap_Extend(
ffc05360: 3f 80 00 00 lis r28,0
ffc05364: 80 7c 27 0c lwz r3,9996(r28)
ffc05368: 7f e5 fb 78 mr r5,r31
ffc0536c: 48 00 60 e1 bl ffc0b44c <_Protected_heap_Extend>
ffc05370: 2f 83 00 00 cmpwi cr7,r3,0
ffc05374: 41 9e 00 50 beq- cr7,ffc053c4 <malloc_sbrk_extend_and_allocate+0xb8>
sbrk(-the_size);
errno = ENOMEM;
return (void *) 0;
}
MSBUMP(space_available, the_size);
ffc05378: 3d 20 00 00 lis r9,0
ffc0537c: 80 7c 27 0c lwz r3,9996(r28)
ffc05380: 80 09 2c 88 lwz r0,11400(r9)
ffc05384: 7f a4 eb 78 mr r4,r29
ffc05388: 38 a0 00 00 li r5,0
ffc0538c: 7c 1f 02 14 add r0,r31,r0
ffc05390: 38 c0 00 00 li r6,0
ffc05394: 90 09 2c 88 stw r0,11400(r9)
ffc05398: 48 00 60 49 bl ffc0b3e0 <_Protected_heap_Allocate_aligned_with_boundary>
ffc0539c: 7c 7e 1b 78 mr r30,r3
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
return return_this;
}
ffc053a0: 80 01 00 1c lwz r0,28(r1)
ffc053a4: 7f c3 f3 78 mr r3,r30
ffc053a8: 83 81 00 08 lwz r28,8(r1)
ffc053ac: 7c 08 03 a6 mtlr r0
ffc053b0: 83 a1 00 0c lwz r29,12(r1)
ffc053b4: 83 c1 00 10 lwz r30,16(r1)
ffc053b8: 83 e1 00 14 lwz r31,20(r1)
ffc053bc: 38 21 00 18 addi r1,r1,24
ffc053c0: 4e 80 00 20 blr
if ( starting_address == (void*) -1 )
return (void *) 0;
if ( !_Protected_heap_Extend(
RTEMS_Malloc_Heap, starting_address, the_size) ) {
sbrk(-the_size);
ffc053c4: 7c 7f 00 d0 neg r3,r31
ffc053c8: 4b ff b0 2d bl ffc003f4 <sbrk>
errno = ENOMEM;
ffc053cc: 48 00 e9 11 bl ffc13cdc <__errno>
ffc053d0: 38 00 00 0c li r0,12
ffc053d4: 90 03 00 00 stw r0,0(r3)
return (void *) 0;
ffc053d8: 4b ff ff c8 b ffc053a0 <malloc_sbrk_extend_and_allocate+0x94>
ffc053dc <malloc_sbrk_initialize>:
* If the starting address is 0 then we are to attempt to
* get length worth of memory using sbrk. Make sure we
* align the address that we get back.
*/
if (!starting_address) {
ffc053dc: 2c 03 00 00 cmpwi r3,0
void *malloc_sbrk_initialize(
void *starting_address,
size_t length
)
{
ffc053e0: 94 21 ff f8 stwu r1,-8(r1)
ffc053e4: 7c 08 02 a6 mflr r0
uintptr_t old_address;
uintptr_t uaddress;
RTEMS_Malloc_Sbrk_amount = length;
ffc053e8: 3d 20 00 00 lis r9,0
ffc053ec: 90 89 27 e0 stw r4,10208(r9)
void *malloc_sbrk_initialize(
void *starting_address,
size_t length
)
{
ffc053f0: 90 01 00 0c stw r0,12(r1)
* If the starting address is 0 then we are to attempt to
* get length worth of memory using sbrk. Make sure we
* align the address that we get back.
*/
if (!starting_address) {
ffc053f4: 41 82 00 14 beq- ffc05408 <malloc_sbrk_initialize+0x2c>
}
starting_address = (void *)uaddress;
}
return starting_address;
}
ffc053f8: 80 01 00 0c lwz r0,12(r1)
ffc053fc: 38 21 00 08 addi r1,r1,8
ffc05400: 7c 08 03 a6 mtlr r0
ffc05404: 4e 80 00 20 blr
* get length worth of memory using sbrk. Make sure we
* align the address that we get back.
*/
if (!starting_address) {
uaddress = (uintptr_t)sbrk(length);
ffc05408: 7c 83 23 78 mr r3,r4
ffc0540c: 4b ff af e9 bl ffc003f4 <sbrk>
if (uaddress == (uintptr_t) -1) {
ffc05410: 2f 83 ff ff cmpwi cr7,r3,-1
ffc05414: 41 9e 00 18 beq- cr7,ffc0542c <malloc_sbrk_initialize+0x50><== ALWAYS TAKEN
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
/* DOES NOT RETURN!!! */
}
if (uaddress & (CPU_HEAP_ALIGNMENT-1)) {
ffc05418: 70 60 00 07 andi. r0,r3,7 <== NOT EXECUTED
ffc0541c: 41 a2 ff dc beq- ffc053f8 <malloc_sbrk_initialize+0x1c> <== NOT EXECUTED
old_address = uaddress;
uaddress = (uaddress + CPU_HEAP_ALIGNMENT) & ~(CPU_HEAP_ALIGNMENT-1);
ffc05420: 38 63 00 08 addi r3,r3,8 <== NOT EXECUTED
ffc05424: 54 63 00 38 rlwinm r3,r3,0,0,28 <== NOT EXECUTED
ffc05428: 4b ff ff d0 b ffc053f8 <malloc_sbrk_initialize+0x1c> <== NOT EXECUTED
if (!starting_address) {
uaddress = (uintptr_t)sbrk(length);
if (uaddress == (uintptr_t) -1) {
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
ffc0542c: 38 60 00 1a li r3,26
ffc05430: 48 00 45 61 bl ffc09990 <rtems_fatal_error_occurred>
ffc11ef4 <memfile_free_blocks_in_table>:
*/
void memfile_free_blocks_in_table(
block_p **block_table,
int entries
)
{
ffc11ef4: 94 21 ff e0 stwu r1,-32(r1)
ffc11ef8: 7c 08 02 a6 mflr r0
ffc11efc: 93 a1 00 14 stw r29,20(r1)
/*
* Now go through all the slots in the table and free the memory.
*/
b = *block_table;
for ( i=0 ; i<entries ; i++ ) {
ffc11f00: 7c 9d 23 79 mr. r29,r4
*/
void memfile_free_blocks_in_table(
block_p **block_table,
int entries
)
{
ffc11f04: 90 01 00 24 stw r0,36(r1)
ffc11f08: 93 61 00 0c stw r27,12(r1)
ffc11f0c: 7c 7b 1b 78 mr r27,r3
ffc11f10: 93 81 00 10 stw r28,16(r1)
ffc11f14: 93 c1 00 18 stw r30,24(r1)
ffc11f18: 93 e1 00 1c stw r31,28(r1)
IMFS_assert( block_table );
/*
* Now go through all the slots in the table and free the memory.
*/
b = *block_table;
ffc11f1c: 80 63 00 00 lwz r3,0(r3)
for ( i=0 ; i<entries ; i++ ) {
ffc11f20: 40 81 00 34 ble- ffc11f54 <memfile_free_blocks_in_table+0x60><== NEVER TAKEN
* memfile_free_blocks_in_table
*
* This is a support routine for IMFS_memfile_remove. It frees all the
* blocks in one of the indirection tables.
*/
void memfile_free_blocks_in_table(
ffc11f24: 3b c3 ff fc addi r30,r3,-4
/*
* Now go through all the slots in the table and free the memory.
*/
b = *block_table;
for ( i=0 ; i<entries ; i++ ) {
ffc11f28: 3b e0 00 00 li r31,0
if ( b[i] ) {
memfile_free_block( b[i] );
b[i] = 0;
ffc11f2c: 3b 80 00 00 li r28,0
* Now go through all the slots in the table and free the memory.
*/
b = *block_table;
for ( i=0 ; i<entries ; i++ ) {
if ( b[i] ) {
ffc11f30: 84 7e 00 04 lwzu r3,4(r30)
/*
* Now go through all the slots in the table and free the memory.
*/
b = *block_table;
for ( i=0 ; i<entries ; i++ ) {
ffc11f34: 3b ff 00 01 addi r31,r31,1
if ( b[i] ) {
ffc11f38: 2f 83 00 00 cmpwi cr7,r3,0
ffc11f3c: 41 9e 00 0c beq- cr7,ffc11f48 <memfile_free_blocks_in_table+0x54>
memfile_free_block( b[i] );
ffc11f40: 4b ff ff 85 bl ffc11ec4 <memfile_free_block>
b[i] = 0;
ffc11f44: 93 9e 00 00 stw r28,0(r30)
/*
* Now go through all the slots in the table and free the memory.
*/
b = *block_table;
for ( i=0 ; i<entries ; i++ ) {
ffc11f48: 7f 9f e8 00 cmpw cr7,r31,r29
ffc11f4c: 40 9e ff e4 bne+ cr7,ffc11f30 <memfile_free_blocks_in_table+0x3c>
ffc11f50: 80 7b 00 00 lwz r3,0(r27)
/*
* Now that all the blocks in the block table are free, we can
* free the block table itself.
*/
memfile_free_block( *block_table );
ffc11f54: 4b ff ff 71 bl ffc11ec4 <memfile_free_block>
*block_table = 0;
ffc11f58: 38 00 00 00 li r0,0
ffc11f5c: 90 1b 00 00 stw r0,0(r27)
}
ffc11f60: 80 01 00 24 lwz r0,36(r1)
ffc11f64: 83 61 00 0c lwz r27,12(r1)
ffc11f68: 7c 08 03 a6 mtlr r0
ffc11f6c: 83 81 00 10 lwz r28,16(r1)
ffc11f70: 83 a1 00 14 lwz r29,20(r1)
ffc11f74: 83 c1 00 18 lwz r30,24(r1)
ffc11f78: 83 e1 00 1c lwz r31,28(r1)
ffc11f7c: 38 21 00 20 addi r1,r1,32
ffc11f80: 4e 80 00 20 blr
ffc126fc <memfile_ftruncate>:
*/
int memfile_ftruncate(
rtems_libio_t *iop,
rtems_off64_t length
)
{
ffc126fc: 94 21 ff e0 stwu r1,-32(r1)
ffc12700: 7c 08 02 a6 mflr r0
ffc12704: 7c 69 1b 78 mr r9,r3
ffc12708: 90 01 00 24 stw r0,36(r1)
ffc1270c: 93 e1 00 1c stw r31,28(r1)
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
ffc12710: 83 e3 00 1c lwz r31,28(r3)
* 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 )
ffc12714: 80 1f 00 50 lwz r0,80(r31)
ffc12718: 7f 80 28 00 cmpw cr7,r0,r5
ffc1271c: 41 9c 00 50 blt- cr7,ffc1276c <memfile_ftruncate+0x70> <== NEVER TAKEN
ffc12720: 41 9e 00 40 beq- cr7,ffc12760 <memfile_ftruncate+0x64>
/*
* 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;
ffc12724: 90 bf 00 50 stw r5,80(r31)
iop->size = the_jnode->info.file.size;
IMFS_update_atime( the_jnode );
ffc12728: 38 61 00 08 addi r3,r1,8
ffc1272c: 38 80 00 00 li r4,0
/*
* 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;
ffc12730: 90 df 00 54 stw r6,84(r31)
iop->size = the_jnode->info.file.size;
ffc12734: 90 a9 00 08 stw r5,8(r9)
ffc12738: 90 c9 00 0c stw r6,12(r9)
IMFS_update_atime( the_jnode );
ffc1273c: 4b ff 2b 29 bl ffc05264 <gettimeofday>
ffc12740: 80 01 00 08 lwz r0,8(r1)
return 0;
ffc12744: 38 60 00 00 li r3,0
* future use and just set the length.
*/
the_jnode->info.file.size = length;
iop->size = the_jnode->info.file.size;
IMFS_update_atime( the_jnode );
ffc12748: 90 1f 00 40 stw r0,64(r31)
return 0;
}
ffc1274c: 80 01 00 24 lwz r0,36(r1)
ffc12750: 83 e1 00 1c lwz r31,28(r1)
ffc12754: 38 21 00 20 addi r1,r1,32
ffc12758: 7c 08 03 a6 mtlr r0
ffc1275c: 4e 80 00 20 blr
* 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 )
ffc12760: 80 1f 00 54 lwz r0,84(r31)
ffc12764: 7f 80 30 40 cmplw cr7,r0,r6
ffc12768: 40 9c ff bc bge+ cr7,ffc12724 <memfile_ftruncate+0x28>
return IMFS_memfile_extend( the_jnode, length );
ffc1276c: 7f e3 fb 78 mr r3,r31
ffc12770: 4b ff f9 fd bl ffc1216c <IMFS_memfile_extend>
iop->size = the_jnode->info.file.size;
IMFS_update_atime( the_jnode );
return 0;
}
ffc12774: 80 01 00 24 lwz r0,36(r1)
ffc12778: 83 e1 00 1c lwz r31,28(r1)
ffc1277c: 38 21 00 20 addi r1,r1,32
ffc12780: 7c 08 03 a6 mtlr r0
ffc12784: 4e 80 00 20 blr
ffc12788 <memfile_lseek>:
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
ffc12788: 94 21 ff f0 stwu r1,-16(r1)
ffc1278c: 7c 08 02 a6 mflr r0
ffc12790: 90 01 00 14 stw r0,20(r1)
ffc12794: 93 c1 00 08 stw r30,8(r1)
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
ffc12798: 83 c3 00 1c lwz r30,28(r3)
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
ffc1279c: 93 e1 00 0c stw r31,12(r1)
ffc127a0: 7c 7f 1b 78 mr r31,r3
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
if (the_jnode->type == IMFS_LINEAR_FILE) {
ffc127a4: 80 1e 00 4c lwz r0,76(r30)
ffc127a8: 2f 80 00 06 cmpwi cr7,r0,6
ffc127ac: 41 9e 00 54 beq- cr7,ffc12800 <memfile_lseek+0x78>
if (iop->offset > the_jnode->info.linearfile.size)
iop->offset = the_jnode->info.linearfile.size;
}
else { /* Must be a block file (IMFS_MEMORY_FILE). */
if (IMFS_memfile_extend( the_jnode, iop->offset ))
ffc127b0: 80 a3 00 10 lwz r5,16(r3)
ffc127b4: 80 c3 00 14 lwz r6,20(r3)
ffc127b8: 7f c3 f3 78 mr r3,r30
ffc127bc: 4b ff f9 b1 bl ffc1216c <IMFS_memfile_extend>
ffc127c0: 2f 83 00 00 cmpwi cr7,r3,0
ffc127c4: 40 9e 00 90 bne- cr7,ffc12854 <memfile_lseek+0xcc>
rtems_set_errno_and_return_minus_one( ENOSPC );
iop->size = the_jnode->info.file.size;
ffc127c8: 81 1e 00 50 lwz r8,80(r30)
ffc127cc: 81 3e 00 54 lwz r9,84(r30)
ffc127d0: 81 5f 00 10 lwz r10,16(r31)
ffc127d4: 81 7f 00 14 lwz r11,20(r31)
ffc127d8: 91 1f 00 08 stw r8,8(r31)
ffc127dc: 91 3f 00 0c stw r9,12(r31)
}
return iop->offset;
}
ffc127e0: 80 01 00 14 lwz r0,20(r1)
ffc127e4: 7d 43 53 78 mr r3,r10
ffc127e8: 7d 64 5b 78 mr r4,r11
ffc127ec: 83 c1 00 08 lwz r30,8(r1)
ffc127f0: 7c 08 03 a6 mtlr r0
ffc127f4: 83 e1 00 0c lwz r31,12(r1)
ffc127f8: 38 21 00 10 addi r1,r1,16
ffc127fc: 4e 80 00 20 blr
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
if (the_jnode->type == IMFS_LINEAR_FILE) {
if (iop->offset > the_jnode->info.linearfile.size)
ffc12800: 81 43 00 10 lwz r10,16(r3)
ffc12804: 80 1e 00 50 lwz r0,80(r30)
ffc12808: 81 63 00 14 lwz r11,20(r3)
ffc1280c: 7f 8a 00 00 cmpw cr7,r10,r0
ffc12810: 81 3e 00 54 lwz r9,84(r30)
ffc12814: 41 9d 00 10 bgt- cr7,ffc12824 <memfile_lseek+0x9c> <== NEVER TAKEN
ffc12818: 40 be ff c8 bne- cr7,ffc127e0 <memfile_lseek+0x58> <== NEVER TAKEN
ffc1281c: 7f 8b 48 40 cmplw cr7,r11,r9
ffc12820: 40 bd ff c0 ble- cr7,ffc127e0 <memfile_lseek+0x58> <== ALWAYS TAKEN
iop->offset = the_jnode->info.linearfile.size;
ffc12824: 7c 0a 03 78 mr r10,r0 <== NOT EXECUTED
ffc12828: 90 1f 00 10 stw r0,16(r31) <== NOT EXECUTED
ffc1282c: 7d 2b 4b 78 mr r11,r9 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSPC );
iop->size = the_jnode->info.file.size;
}
return iop->offset;
}
ffc12830: 80 01 00 14 lwz r0,20(r1) <== NOT EXECUTED
ffc12834: 7d 43 53 78 mr r3,r10 <== NOT EXECUTED
the_jnode = iop->pathinfo.node_access;
if (the_jnode->type == IMFS_LINEAR_FILE) {
if (iop->offset > the_jnode->info.linearfile.size)
iop->offset = the_jnode->info.linearfile.size;
ffc12838: 91 3f 00 14 stw r9,20(r31) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSPC );
iop->size = the_jnode->info.file.size;
}
return iop->offset;
}
ffc1283c: 7d 64 5b 78 mr r4,r11 <== NOT EXECUTED
ffc12840: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc12844: 83 c1 00 08 lwz r30,8(r1) <== NOT EXECUTED
ffc12848: 83 e1 00 0c lwz r31,12(r1) <== NOT EXECUTED
ffc1284c: 38 21 00 10 addi r1,r1,16 <== NOT EXECUTED
ffc12850: 4e 80 00 20 blr <== NOT EXECUTED
if (iop->offset > the_jnode->info.linearfile.size)
iop->offset = the_jnode->info.linearfile.size;
}
else { /* Must be a block file (IMFS_MEMORY_FILE). */
if (IMFS_memfile_extend( the_jnode, iop->offset ))
rtems_set_errno_and_return_minus_one( ENOSPC );
ffc12854: 48 00 15 39 bl ffc13d8c <__errno>
ffc12858: 38 00 00 1c li r0,28
ffc1285c: 90 03 00 00 stw r0,0(r3)
ffc12860: 39 40 ff ff li r10,-1
ffc12864: 39 60 ff ff li r11,-1
ffc12868: 4b ff ff 78 b ffc127e0 <memfile_lseek+0x58>
ffc1261c <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
ffc1261c: 94 21 ff f0 stwu r1,-16(r1)
ffc12620: 7c 08 02 a6 mflr r0
ffc12624: 90 01 00 14 stw r0,20(r1)
the_jnode = iop->pathinfo.node_access;
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
ffc12628: 80 03 00 18 lwz r0,24(r3)
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
ffc1262c: 93 c1 00 08 stw r30,8(r1)
the_jnode = iop->pathinfo.node_access;
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
ffc12630: 70 09 02 04 andi. r9,r0,516
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
ffc12634: 93 e1 00 0c stw r31,12(r1)
ffc12638: 7c 7f 1b 78 mr r31,r3
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
ffc1263c: 83 c3 00 1c lwz r30,28(r3)
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
ffc12640: 41 82 00 10 beq- ffc12650 <memfile_open+0x34>
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
ffc12644: 81 3e 00 4c lwz r9,76(r30)
ffc12648: 2f 89 00 06 cmpwi cr7,r9,6
ffc1264c: 41 9e 00 4c beq- cr7,ffc12698 <memfile_open+0x7c> <== NEVER TAKEN
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))
ffc12650: 81 5e 00 50 lwz r10,80(r30)
ffc12654: 81 7e 00 54 lwz r11,84(r30)
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
ffc12658: 70 09 02 00 andi. r9,r0,512
ffc1265c: 40 82 00 28 bne- ffc12684 <memfile_open+0x68>
iop->offset = the_jnode->info.file.size;
iop->size = the_jnode->info.file.size;
ffc12660: 91 5f 00 08 stw r10,8(r31)
return 0;
ffc12664: 38 60 00 00 li r3,0
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
iop->offset = the_jnode->info.file.size;
iop->size = the_jnode->info.file.size;
ffc12668: 91 7f 00 0c stw r11,12(r31)
return 0;
}
ffc1266c: 80 01 00 14 lwz r0,20(r1)
ffc12670: 83 c1 00 08 lwz r30,8(r1)
ffc12674: 7c 08 03 a6 mtlr r0
ffc12678: 83 e1 00 0c lwz r31,12(r1)
ffc1267c: 38 21 00 10 addi r1,r1,16
ffc12680: 4e 80 00 20 blr
if ((count != 0)
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
iop->offset = the_jnode->info.file.size;
ffc12684: 91 5f 00 10 stw r10,16(r31)
ffc12688: 91 7f 00 14 stw r11,20(r31)
ffc1268c: 81 5e 00 50 lwz r10,80(r30)
ffc12690: 81 7e 00 54 lwz r11,84(r30)
ffc12694: 4b ff ff cc b ffc12660 <memfile_open+0x44>
/*
* 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;
ffc12698: 81 1e 00 54 lwz r8,84(r30) <== NOT EXECUTED
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->type = IMFS_MEMORY_FILE;
the_jnode->info.file.size = 0;
the_jnode->info.file.indirect = 0;
ffc1269c: 38 00 00 00 li r0,0 <== NOT EXECUTED
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->type = IMFS_MEMORY_FILE;
ffc126a0: 39 20 00 05 li r9,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;
ffc126a4: 80 fe 00 58 lwz r7,88(r30) <== NOT EXECUTED
the_jnode->type = IMFS_MEMORY_FILE;
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)
ffc126a8: 2f 88 00 00 cmpwi cr7,r8,0 <== NOT EXECUTED
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->type = IMFS_MEMORY_FILE;
ffc126ac: 91 3e 00 4c stw r9,76(r30) <== NOT EXECUTED
the_jnode->info.file.size = 0;
ffc126b0: 39 40 00 00 li r10,0 <== NOT EXECUTED
ffc126b4: 39 60 00 00 li r11,0 <== NOT EXECUTED
ffc126b8: 91 5e 00 50 stw r10,80(r30) <== NOT EXECUTED
ffc126bc: 91 7e 00 54 stw r11,84(r30) <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
ffc126c0: 90 1e 00 58 stw r0,88(r30) <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
ffc126c4: 90 1e 00 5c stw r0,92(r30) <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
ffc126c8: 90 1e 00 60 stw r0,96(r30) <== NOT EXECUTED
if ((count != 0)
ffc126cc: 40 9e 00 0c bne- cr7,ffc126d8 <memfile_open+0xbc> <== NOT EXECUTED
ffc126d0: 80 03 00 18 lwz r0,24(r3) <== NOT EXECUTED
ffc126d4: 4b ff ff 84 b ffc12658 <memfile_open+0x3c> <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
ffc126d8: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc126dc: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc126e0: 38 c0 00 00 li r6,0 <== NOT EXECUTED
ffc126e4: 4b ff fc 85 bl ffc12368 <IMFS_memfile_write> <== NOT EXECUTED
ffc126e8: 2f 83 ff ff cmpwi cr7,r3,-1 <== NOT EXECUTED
return -1;
ffc126ec: 38 60 ff ff li r3,-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))
ffc126f0: 41 be ff 7c beq- cr7,ffc1266c <memfile_open+0x50> <== NOT EXECUTED
ffc126f4: 80 1f 00 18 lwz r0,24(r31) <== NOT EXECUTED
ffc126f8: 4b ff ff 58 b ffc12650 <memfile_open+0x34> <== NOT EXECUTED
ffc05718 <mknod>:
int mknod(
const char *pathname,
mode_t mode,
dev_t dev
)
{
ffc05718: 94 21 ff c8 stwu r1,-56(r1)
ffc0571c: 7c 08 02 a6 mflr r0
ffc05720: 90 01 00 3c stw r0,60(r1)
int result;
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & S_IFMT)
ffc05724: 54 80 04 26 rlwinm r0,r4,0,16,19
ffc05728: 2f 80 40 00 cmpwi cr7,r0,16384
int mknod(
const char *pathname,
mode_t mode,
dev_t dev
)
{
ffc0572c: 93 81 00 28 stw r28,40(r1)
ffc05730: 7c bc 2b 78 mr r28,r5
ffc05734: 93 a1 00 2c stw r29,44(r1)
ffc05738: 7c dd 33 78 mr r29,r6
ffc0573c: 93 c1 00 30 stw r30,48(r1)
ffc05740: 7c 9e 23 78 mr r30,r4
ffc05744: 93 e1 00 34 stw r31,52(r1)
ffc05748: 7c 7f 1b 78 mr r31,r3
int result;
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & S_IFMT)
ffc0574c: 41 9e 00 44 beq- cr7,ffc05790 <mknod+0x78>
ffc05750: 2b 80 40 00 cmplwi cr7,r0,16384
ffc05754: 40 9d 00 2c ble- cr7,ffc05780 <mknod+0x68>
ffc05758: 2f 80 60 00 cmpwi cr7,r0,24576
ffc0575c: 41 9e 00 34 beq- cr7,ffc05790 <mknod+0x78>
ffc05760: 6c 09 ff ff xoris r9,r0,65535
ffc05764: 2f 89 80 00 cmpwi cr7,r9,-32768
ffc05768: 41 9e 00 28 beq- cr7,ffc05790 <mknod+0x78> <== ALWAYS TAKEN
case S_IFBLK:
case S_IFREG:
case S_IFIFO:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
ffc0576c: 48 00 e6 21 bl ffc13d8c <__errno>
ffc05770: 38 00 00 16 li r0,22
ffc05774: 90 03 00 00 stw r0,0(r3)
ffc05778: 3b e0 ff ff li r31,-1
ffc0577c: 48 00 00 80 b ffc057fc <mknod+0xe4>
int result;
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & S_IFMT)
ffc05780: 2f 80 10 00 cmpwi cr7,r0,4096
ffc05784: 41 9e 00 0c beq- cr7,ffc05790 <mknod+0x78>
ffc05788: 2f 80 20 00 cmpwi cr7,r0,8192
ffc0578c: 40 9e ff e0 bne+ cr7,ffc0576c <mknod+0x54>
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_filesystem_get_start_loc( pathname, &i, &temp_loc );
ffc05790: 7f e3 fb 78 mr r3,r31
ffc05794: 38 81 00 0c addi r4,r1,12
ffc05798: 38 a1 00 10 addi r5,r1,16
ffc0579c: 48 00 0c 95 bl ffc06430 <rtems_filesystem_get_start_loc>
result = (*temp_loc.ops->evalformake_h)(
ffc057a0: 81 21 00 1c lwz r9,28(r1)
ffc057a4: 80 61 00 0c lwz r3,12(r1)
ffc057a8: 38 81 00 10 addi r4,r1,16
ffc057ac: 80 09 00 04 lwz r0,4(r9)
ffc057b0: 38 a1 00 08 addi r5,r1,8
ffc057b4: 7c 7f 1a 14 add r3,r31,r3
ffc057b8: 7c 09 03 a6 mtctr r0
&pathname[i],
&temp_loc,
&name_start
);
if ( result != 0 )
return -1;
ffc057bc: 3b e0 ff ff li r31,-1
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_filesystem_get_start_loc( pathname, &i, &temp_loc );
result = (*temp_loc.ops->evalformake_h)(
ffc057c0: 4e 80 04 21 bctrl
&pathname[i],
&temp_loc,
&name_start
);
if ( result != 0 )
ffc057c4: 2f 83 00 00 cmpwi cr7,r3,0
ffc057c8: 40 9e 00 34 bne- cr7,ffc057fc <mknod+0xe4>
return -1;
result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
ffc057cc: 81 21 00 1c lwz r9,28(r1)
ffc057d0: 7f c4 f3 78 mr r4,r30
ffc057d4: 80 61 00 08 lwz r3,8(r1)
ffc057d8: 7f 85 e3 78 mr r5,r28
ffc057dc: 80 09 00 14 lwz r0,20(r9)
ffc057e0: 7f a6 eb 78 mr r6,r29
ffc057e4: 38 e1 00 10 addi r7,r1,16
ffc057e8: 7c 09 03 a6 mtctr r0
ffc057ec: 4e 80 04 21 bctrl
ffc057f0: 7c 7f 1b 78 mr r31,r3
rtems_filesystem_freenode( &temp_loc );
ffc057f4: 38 61 00 10 addi r3,r1,16
ffc057f8: 4b ff f9 79 bl ffc05170 <rtems_filesystem_freenode>
return result;
}
ffc057fc: 80 01 00 3c lwz r0,60(r1)
ffc05800: 7f e3 fb 78 mr r3,r31
ffc05804: 83 81 00 28 lwz r28,40(r1)
ffc05808: 7c 08 03 a6 mtlr r0
ffc0580c: 83 a1 00 2c lwz r29,44(r1)
ffc05810: 83 c1 00 30 lwz r30,48(r1)
ffc05814: 83 e1 00 34 lwz r31,52(r1)
ffc05818: 38 21 00 38 addi r1,r1,56
ffc0581c: 4e 80 00 20 blr
ffc058ec <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
ffc058ec: 7d 80 00 26 mfcr r12
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
ffc058f0: 2b 86 00 01 cmplwi cr7,r6,1
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
ffc058f4: 94 21 ff a0 stwu r1,-96(r1)
ffc058f8: 7c 08 02 a6 mflr r0
ffc058fc: 93 01 00 40 stw r24,64(r1)
ffc05900: 7c b8 2b 78 mr r24,r5
ffc05904: 93 41 00 48 stw r26,72(r1)
ffc05908: 7c da 33 78 mr r26,r6
ffc0590c: 93 61 00 4c stw r27,76(r1)
ffc05910: 7c 7b 1b 78 mr r27,r3
ffc05914: 93 81 00 50 stw r28,80(r1)
ffc05918: 7c 9c 23 78 mr r28,r4
ffc0591c: 93 c1 00 58 stw r30,88(r1)
ffc05920: 7c fe 3b 78 mr r30,r7
ffc05924: 90 01 00 64 stw r0,100(r1)
ffc05928: 92 61 00 2c stw r19,44(r1)
ffc0592c: 92 81 00 30 stw r20,48(r1)
ffc05930: 92 a1 00 34 stw r21,52(r1)
ffc05934: 92 c1 00 38 stw r22,56(r1)
ffc05938: 92 e1 00 3c stw r23,60(r1)
ffc0593c: 93 21 00 44 stw r25,68(r1)
ffc05940: 93 a1 00 54 stw r29,84(r1)
ffc05944: 93 e1 00 5c stw r31,92(r1)
ffc05948: 91 81 00 28 stw r12,40(r1)
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
ffc0594c: 41 9d 02 38 bgt- cr7,ffc05b84 <mount+0x298>
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
ffc05950: 7c a3 2b 78 mr r3,r5
ffc05954: 48 00 a1 11 bl ffc0fa64 <rtems_filesystem_get_mount_handler>
if ( !mount_h )
ffc05958: 7c 7d 1b 79 mr. r29,r3
ffc0595c: 41 82 02 28 beq- ffc05b84 <mount+0x298>
{
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;
ffc05960: 7f 80 00 34 cntlzw r0,r28
ffc05964: 54 00 d9 7e rlwinm r0,r0,27,5,31
ffc05968: 68 00 00 01 xori r0,r0,1
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
ffc0596c: 2e 00 00 00 cmpwi cr4,r0,0
ffc05970: 41 92 02 00 beq- cr4,ffc05b70 <mount+0x284>
* 4) The mount point exists with the proper permissions to allow mounting
* 5) The selected mount point already has a file system mounted to it
*
*/
int mount(
ffc05974: 7f 83 e3 78 mr r3,r28
ffc05978: 48 00 fd 41 bl ffc156b8 <strlen>
ffc0597c: 7f 93 e3 78 mr r19,r28
ffc05980: 7c 74 1b 78 mr r20,r3
ffc05984: 3a c3 00 01 addi r22,r3,1
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
ffc05988: 7f 03 c3 78 mr r3,r24
ffc0598c: 48 00 fd 2d bl ffc156b8 <strlen>
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
ffc05990: 2f 9b 00 00 cmpwi cr7,r27,0
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
ffc05994: 7c 75 1b 78 mr r21,r3
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
ffc05998: 3b 20 00 00 li r25,0
ffc0599c: 41 9e 00 10 beq- cr7,ffc059ac <mount+0xc0>
ffc059a0: 7f 63 db 78 mr r3,r27
ffc059a4: 48 00 fd 15 bl ffc156b8 <strlen>
ffc059a8: 3b 23 00 01 addi r25,r3,1
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
ffc059ac: 7c 95 b2 14 add r4,r21,r22
ffc059b0: 38 84 00 75 addi r4,r4,117
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
ffc059b4: 38 60 00 01 li r3,1
ffc059b8: 7c 84 ca 14 add r4,r4,r25
ffc059bc: 4b ff f1 dd bl ffc04b98 <calloc>
if ( mt_entry != NULL ) {
ffc059c0: 7c 7f 1b 79 mr. r31,r3
ffc059c4: 41 82 01 98 beq- ffc05b5c <mount+0x270> <== NEVER TAKEN
char *str = (char *) mt_entry + sizeof( *mt_entry );
ffc059c8: 3a ff 00 74 addi r23,r31,116
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
ffc059cc: 3a b5 00 01 addi r21,r21,1
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
if ( mt_entry != NULL ) {
char *str = (char *) mt_entry + sizeof( *mt_entry );
memcpy( str, filesystemtype, filesystemtype_size );
ffc059d0: 7f 04 c3 78 mr r4,r24
ffc059d4: 7e a5 ab 78 mr r5,r21
ffc059d8: 7e e3 bb 78 mr r3,r23
ffc059dc: 48 00 f0 ed bl ffc14ac8 <memcpy>
mt_entry->type = str;
str += filesystemtype_size;
ffc059e0: 7f 17 aa 14 add r24,r23,r21
if ( mt_entry != NULL ) {
char *str = (char *) mt_entry + sizeof( *mt_entry );
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
ffc059e4: 92 ff 00 6c stw r23,108(r31)
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
ffc059e8: 7f 25 cb 78 mr r5,r25
ffc059ec: 7f 64 db 78 mr r4,r27
ffc059f0: 7f 03 c3 78 mr r3,r24
ffc059f4: 48 00 f0 d5 bl ffc14ac8 <memcpy>
mt_entry->dev = str;
str += source_size;
ffc059f8: 7f 38 ca 14 add r25,r24,r25
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
mt_entry->dev = str;
ffc059fc: 93 1f 00 70 stw r24,112(r31)
str += source_size;
memcpy( str, target, target_size );
ffc05a00: 7e 64 9b 78 mr r4,r19
ffc05a04: 7e c5 b3 78 mr r5,r22
ffc05a08: 7f 23 cb 78 mr r3,r25
ffc05a0c: 48 00 f0 bd bl ffc14ac8 <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;
ffc05a10: 3c 80 ff c2 lis r4,-62
memcpy( str, source_or_null, source_size );
mt_entry->dev = str;
str += source_size;
memcpy( str, target, target_size );
mt_entry->target = str;
ffc05a14: 93 3f 00 68 stw r25,104(r31)
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;
ffc05a18: 38 7f 00 38 addi r3,r31,56
ffc05a1c: 38 84 0b f0 addi r4,r4,3056
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
mt_entry->mt_fs_root.mt_entry = mt_entry;
ffc05a20: 93 ff 00 2c stw r31,44(r31)
mt_entry->options = options;
mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
ffc05a24: 38 a0 00 30 li r5,48
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
mt_entry->mt_fs_root.mt_entry = mt_entry;
mt_entry->options = options;
ffc05a28: 93 5f 00 30 stw r26,48(r31)
mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
ffc05a2c: 48 00 f0 9d bl ffc14ac8 <memcpy>
/*
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
ffc05a30: 40 92 00 80 bne- cr4,ffc05ab0 <mount+0x1c4>
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
ffc05a34: 3d 20 00 00 lis r9,0
ffc05a38: 39 69 21 a4 addi r11,r9,8612
}
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
ffc05a3c: 81 29 21 a4 lwz r9,8612(r9)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
ffc05a40: 38 0b 00 04 addi r0,r11,4
ffc05a44: 7f 89 00 00 cmpw cr7,r9,r0
ffc05a48: 41 9e 00 c0 beq- cr7,ffc05b08 <mount+0x21c> <== ALWAYS TAKEN
errno = EINVAL;
ffc05a4c: 48 00 e3 41 bl ffc13d8c <__errno> <== NOT EXECUTED
ffc05a50: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc05a54: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
return 0;
cleanup_and_bail:
free( mt_entry );
ffc05a58: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc05a5c: 4b ff f7 41 bl ffc0519c <free> <== NOT EXECUTED
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
return -1;
ffc05a60: 38 60 ff ff li r3,-1 <== NOT EXECUTED
}
ffc05a64: 80 01 00 64 lwz r0,100(r1)
ffc05a68: 81 81 00 28 lwz r12,40(r1)
ffc05a6c: 7c 08 03 a6 mtlr r0
ffc05a70: 82 61 00 2c lwz r19,44(r1)
ffc05a74: 82 81 00 30 lwz r20,48(r1)
ffc05a78: 7d 80 81 20 mtcrf 8,r12
ffc05a7c: 82 a1 00 34 lwz r21,52(r1)
ffc05a80: 82 c1 00 38 lwz r22,56(r1)
ffc05a84: 82 e1 00 3c lwz r23,60(r1)
ffc05a88: 83 01 00 40 lwz r24,64(r1)
ffc05a8c: 83 21 00 44 lwz r25,68(r1)
ffc05a90: 83 41 00 48 lwz r26,72(r1)
ffc05a94: 83 61 00 4c lwz r27,76(r1)
ffc05a98: 83 81 00 50 lwz r28,80(r1)
ffc05a9c: 83 a1 00 54 lwz r29,84(r1)
ffc05aa0: 83 c1 00 58 lwz r30,88(r1)
ffc05aa4: 83 e1 00 5c lwz r31,92(r1)
ffc05aa8: 38 21 00 60 addi r1,r1,96
ffc05aac: 4e 80 00 20 blr
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
if ( rtems_filesystem_evaluate_path(
ffc05ab0: 7f 83 e3 78 mr r3,r28
ffc05ab4: 7e 84 a3 78 mr r4,r20
ffc05ab8: 38 a0 00 07 li r5,7
ffc05abc: 38 c1 00 08 addi r6,r1,8
ffc05ac0: 38 e0 00 01 li r7,1
ffc05ac4: 4b ff f5 51 bl ffc05014 <rtems_filesystem_evaluate_path>
ffc05ac8: 2f 83 ff ff cmpwi cr7,r3,-1
ffc05acc: 41 be ff 8c beq- cr7,ffc05a58 <mount+0x16c> <== NEVER TAKEN
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
ffc05ad0: 81 21 00 14 lwz r9,20(r1)
ffc05ad4: 38 61 00 08 addi r3,r1,8
ffc05ad8: 80 09 00 10 lwz r0,16(r9)
ffc05adc: 7c 09 03 a6 mtctr r0
ffc05ae0: 4e 80 04 21 bctrl
ffc05ae4: 2f 83 00 01 cmpwi cr7,r3,1
ffc05ae8: 41 9e 01 20 beq- cr7,ffc05c08 <mount+0x31c>
errno = ENOTDIR;
ffc05aec: 48 00 e2 a1 bl ffc13d8c <__errno>
ffc05af0: 38 00 00 14 li r0,20
ffc05af4: 90 03 00 00 stw r0,0(r3)
return 0;
cleanup_and_bail:
free( mt_entry );
ffc05af8: 7f e3 fb 78 mr r3,r31
ffc05afc: 4b ff f6 a1 bl ffc0519c <free>
ffc05b00: 3b 81 00 08 addi r28,r1,8
ffc05b04: 48 00 00 48 b ffc05b4c <mount+0x260>
)
{
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;
ffc05b08: 3b 80 00 00 li r28,0
* 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 ) ) {
ffc05b0c: 7f e3 fb 78 mr r3,r31
ffc05b10: 7f a9 03 a6 mtctr r29
ffc05b14: 7f c4 f3 78 mr r4,r30
ffc05b18: 4e 80 04 21 bctrl
ffc05b1c: 2f 83 00 00 cmpwi cr7,r3,0
ffc05b20: 41 9e 00 78 beq- cr7,ffc05b98 <mount+0x2ac>
/*
* Try to undo the mount operation
*/
loc.ops->unmount_h( mt_entry );
ffc05b24: 81 21 00 14 lwz r9,20(r1)
ffc05b28: 7f e3 fb 78 mr r3,r31
ffc05b2c: 80 09 00 28 lwz r0,40(r9)
ffc05b30: 7c 09 03 a6 mtctr r0
ffc05b34: 4e 80 04 21 bctrl
return 0;
cleanup_and_bail:
free( mt_entry );
ffc05b38: 7f e3 fb 78 mr r3,r31
ffc05b3c: 4b ff f6 61 bl ffc0519c <free>
if ( loc_to_free )
ffc05b40: 2f 9c 00 00 cmpwi cr7,r28,0
rtems_filesystem_freenode( loc_to_free );
return -1;
ffc05b44: 38 60 ff ff li r3,-1
cleanup_and_bail:
free( mt_entry );
if ( loc_to_free )
ffc05b48: 41 be ff 1c beq- cr7,ffc05a64 <mount+0x178> <== NEVER TAKEN
rtems_filesystem_freenode( loc_to_free );
ffc05b4c: 7f 83 e3 78 mr r3,r28
ffc05b50: 4b ff f6 21 bl ffc05170 <rtems_filesystem_freenode>
return -1;
ffc05b54: 38 60 ff ff li r3,-1
ffc05b58: 4b ff ff 0c b ffc05a64 <mount+0x178>
target,
filesystemtype,
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
ffc05b5c: 48 00 e2 31 bl ffc13d8c <__errno> <== NOT EXECUTED
ffc05b60: 38 00 00 0c li r0,12 <== NOT EXECUTED
ffc05b64: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc05b68: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc05b6c: 4b ff fe f8 b ffc05a64 <mount+0x178> <== NOT EXECUTED
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
ffc05b70: 3e 60 ff c2 lis r19,-62
ffc05b74: 3a c0 00 02 li r22,2
ffc05b78: 3a 80 00 01 li r20,1
ffc05b7c: 3a 73 07 00 addi r19,r19,1792
ffc05b80: 4b ff fe 08 b ffc05988 <mount+0x9c>
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
if ( !mount_h )
rtems_set_errno_and_return_minus_one( EINVAL );
ffc05b84: 48 00 e2 09 bl ffc13d8c <__errno>
ffc05b88: 38 00 00 16 li r0,22
ffc05b8c: 90 03 00 00 stw r0,0(r3)
ffc05b90: 38 60 ff ff li r3,-1
ffc05b94: 4b ff fe d0 b ffc05a64 <mount+0x178>
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 );
ffc05b98: 3f c0 00 00 lis r30,0
ffc05b9c: 80 7e 27 f8 lwz r3,10232(r30)
ffc05ba0: 38 80 00 00 li r4,0
ffc05ba4: 38 a0 00 00 li r5,0
ffc05ba8: 48 00 38 31 bl ffc093d8 <rtems_semaphore_obtain>
/*
* Add the mount table entry to the mount table chain
*/
rtems_libio_lock();
rtems_chain_append( &mount_chain, &mt_entry->Node );
ffc05bac: 3c 60 00 00 lis r3,0
ffc05bb0: 38 63 21 a4 addi r3,r3,8612
ffc05bb4: 7f e4 fb 78 mr r4,r31
ffc05bb8: 48 00 46 35 bl ffc0a1ec <_Chain_Append>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
ffc05bbc: 80 7e 27 f8 lwz r3,10232(r30)
ffc05bc0: 48 00 39 a5 bl ffc09564 <rtems_semaphore_release>
rtems_libio_unlock();
if ( !has_target )
ffc05bc4: 40 92 00 3c bne- cr4,ffc05c00 <mount+0x314>
rtems_filesystem_root = mt_entry->mt_fs_root;
ffc05bc8: 3d 20 00 00 lis r9,0
ffc05bcc: 80 ff 00 1c lwz r7,28(r31)
ffc05bd0: 81 29 27 7c lwz r9,10108(r9)
return 0;
ffc05bd4: 38 60 00 00 li r3,0
rtems_libio_lock();
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
if ( !has_target )
rtems_filesystem_root = mt_entry->mt_fs_root;
ffc05bd8: 81 1f 00 20 lwz r8,32(r31)
ffc05bdc: 81 5f 00 24 lwz r10,36(r31)
ffc05be0: 81 7f 00 28 lwz r11,40(r31)
ffc05be4: 80 1f 00 2c lwz r0,44(r31)
ffc05be8: 90 e9 00 18 stw r7,24(r9)
ffc05bec: 91 09 00 1c stw r8,28(r9)
ffc05bf0: 91 49 00 20 stw r10,32(r9)
ffc05bf4: 91 69 00 24 stw r11,36(r9)
ffc05bf8: 90 09 00 28 stw r0,40(r9)
ffc05bfc: 4b ff fe 68 b ffc05a64 <mount+0x178>
return 0;
ffc05c00: 38 60 00 00 li r3,0
ffc05c04: 4b ff fe 60 b ffc05a64 <mount+0x178>
/*
* You can only mount one file system onto a single mount point.
*/
if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) {
ffc05c08: 80 81 00 08 lwz r4,8(r1)
ffc05c0c: 3c 60 ff c0 lis r3,-64
ffc05c10: 38 63 58 20 addi r3,r3,22560
ffc05c14: 4b ff fc 21 bl ffc05834 <rtems_filesystem_mount_iterate>
ffc05c18: 2f 83 00 00 cmpwi cr7,r3,0
ffc05c1c: 41 9e 00 14 beq- cr7,ffc05c30 <mount+0x344>
errno = EBUSY;
ffc05c20: 48 00 e1 6d bl ffc13d8c <__errno>
ffc05c24: 38 00 00 10 li r0,16
ffc05c28: 90 03 00 00 stw r0,0(r3)
goto cleanup_and_bail;
ffc05c2c: 4b ff fe cc b ffc05af8 <mount+0x20c>
* 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;
ffc05c30: 80 01 00 08 lwz r0,8(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 ) ) {
ffc05c34: 7f e3 fb 78 mr r3,r31
* 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;
ffc05c38: 81 21 00 14 lwz r9,20(r1)
if ( has_target ) {
if ( rtems_filesystem_evaluate_path(
target, target_length, RTEMS_LIBIO_PERMS_RWX, &loc, true ) == -1 )
goto cleanup_and_bail;
loc_to_free = &loc;
ffc05c3c: 3b 81 00 08 addi r28,r1,8
* 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;
ffc05c40: 90 1f 00 08 stw r0,8(r31)
mt_entry->mt_point_node.handlers = loc.handlers;
ffc05c44: 80 01 00 10 lwz r0,16(r1)
mt_entry->mt_point_node.ops = loc.ops;
ffc05c48: 91 3f 00 14 stw r9,20(r31)
* 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;
ffc05c4c: 90 1f 00 10 stw r0,16(r31)
mt_entry->mt_point_node.ops = loc.ops;
mt_entry->mt_point_node.mt_entry = loc.mt_entry;
ffc05c50: 80 01 00 18 lwz r0,24(r1)
ffc05c54: 90 1f 00 18 stw r0,24(r31)
/*
* 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 ) ) {
ffc05c58: 80 09 00 20 lwz r0,32(r9)
ffc05c5c: 7c 09 03 a6 mtctr r0
ffc05c60: 4e 80 04 21 bctrl
ffc05c64: 2f 83 00 00 cmpwi cr7,r3,0
ffc05c68: 41 be fe a4 beq- cr7,ffc05b0c <mount+0x220> <== ALWAYS TAKEN
ffc05c6c: 4b ff fe 8c b ffc05af8 <mount+0x20c> <== NOT EXECUTED
ffc05758 <mount_and_make_target_path>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
ffc05758: 94 21 ff e0 stwu r1,-32(r1)
ffc0575c: 7c 08 02 a6 mflr r0
ffc05760: 93 e1 00 1c stw r31,28(r1)
int rv = -1;
if (target != NULL) {
ffc05764: 7c 9f 23 79 mr. r31,r4
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
ffc05768: 93 61 00 0c stw r27,12(r1)
ffc0576c: 7c bb 2b 78 mr r27,r5
ffc05770: 93 81 00 10 stw r28,16(r1)
ffc05774: 7c dc 33 78 mr r28,r6
ffc05778: 93 a1 00 14 stw r29,20(r1)
ffc0577c: 7c fd 3b 78 mr r29,r7
ffc05780: 93 c1 00 18 stw r30,24(r1)
ffc05784: 7c 7e 1b 78 mr r30,r3
ffc05788: 90 01 00 24 stw r0,36(r1)
int rv = -1;
if (target != NULL) {
ffc0578c: 41 82 00 78 beq- ffc05804 <mount_and_make_target_path+0xac>
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
ffc05790: 7f e3 fb 78 mr r3,r31
ffc05794: 38 80 01 ff li r4,511
ffc05798: 48 00 0b d9 bl ffc06370 <rtems_mkdir>
if (rv == 0) {
ffc0579c: 2c 03 00 00 cmpwi r3,0
ffc057a0: 41 82 00 28 beq- ffc057c8 <mount_and_make_target_path+0x70><== ALWAYS TAKEN
} else {
errno = EINVAL;
}
return rv;
}
ffc057a4: 80 01 00 24 lwz r0,36(r1)
ffc057a8: 83 61 00 0c lwz r27,12(r1)
ffc057ac: 7c 08 03 a6 mtlr r0
ffc057b0: 83 81 00 10 lwz r28,16(r1)
ffc057b4: 83 a1 00 14 lwz r29,20(r1)
ffc057b8: 83 c1 00 18 lwz r30,24(r1)
ffc057bc: 83 e1 00 1c lwz r31,28(r1)
ffc057c0: 38 21 00 20 addi r1,r1,32
ffc057c4: 4e 80 00 20 blr
int rv = -1;
if (target != NULL) {
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
if (rv == 0) {
rv = mount(
ffc057c8: 7f c3 f3 78 mr r3,r30
ffc057cc: 7f e4 fb 78 mr r4,r31
ffc057d0: 7f 65 db 78 mr r5,r27
ffc057d4: 7f 86 e3 78 mr r6,r28
ffc057d8: 7f a7 eb 78 mr r7,r29
ffc057dc: 48 00 01 09 bl ffc058e4 <mount>
} else {
errno = EINVAL;
}
return rv;
}
ffc057e0: 80 01 00 24 lwz r0,36(r1)
ffc057e4: 83 61 00 0c lwz r27,12(r1)
ffc057e8: 7c 08 03 a6 mtlr r0
ffc057ec: 83 81 00 10 lwz r28,16(r1)
ffc057f0: 83 a1 00 14 lwz r29,20(r1)
ffc057f4: 83 c1 00 18 lwz r30,24(r1)
ffc057f8: 83 e1 00 1c lwz r31,28(r1)
ffc057fc: 38 21 00 20 addi r1,r1,32
ffc05800: 4e 80 00 20 blr
options,
data
);
}
} else {
errno = EINVAL;
ffc05804: 48 00 e1 21 bl ffc13924 <__errno>
ffc05808: 38 00 00 16 li r0,22
ffc0580c: 90 03 00 00 stw r0,0(r3)
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
int rv = -1;
ffc05810: 38 60 ff ff li r3,-1
ffc05814: 4b ff ff 90 b ffc057a4 <mount_and_make_target_path+0x4c>
ffc0ecd0 <mq_open>:
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc0ecd0: 3d 20 00 00 lis r9,0
int oflag,
...
/* mode_t mode, */
/* struct mq_attr attr */
)
{
ffc0ecd4: 94 21 ff b0 stwu r1,-80(r1)
ffc0ecd8: 7c 08 02 a6 mflr r0
ffc0ecdc: 81 69 2a 70 lwz r11,10864(r9)
ffc0ece0: 7d 80 00 26 mfcr r12
ffc0ece4: 90 01 00 54 stw r0,84(r1)
ffc0ece8: 39 6b 00 01 addi r11,r11,1
ffc0ecec: 91 69 2a 70 stw r11,10864(r9)
ffc0ecf0: 93 81 00 40 stw r28,64(r1)
ffc0ecf4: 7c 7c 1b 78 mr r28,r3
ffc0ecf8: 93 c1 00 48 stw r30,72(r1)
ffc0ecfc: 7c 9e 23 78 mr r30,r4
ffc0ed00: 93 41 00 38 stw r26,56(r1)
ffc0ed04: 93 61 00 3c stw r27,60(r1)
ffc0ed08: 93 a1 00 44 stw r29,68(r1)
ffc0ed0c: 93 e1 00 4c stw r31,76(r1)
ffc0ed10: 91 81 00 34 stw r12,52(r1)
ffc0ed14: 90 a1 00 28 stw r5,40(r1)
ffc0ed18: 90 c1 00 2c stw r6,44(r1)
return _Thread_Dispatch_disable_level;
ffc0ed1c: 80 09 2a 70 lwz r0,10864(r9)
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
ffc0ed20: 54 80 bf fe rlwinm r0,r4,23,31,31
ffc0ed24: 2e 00 00 00 cmpwi cr4,r0,0
/* struct mq_attr attr */
)
{
va_list arg;
mode_t mode;
struct mq_attr *attr = NULL;
ffc0ed28: 3b 40 00 00 li r26,0
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
ffc0ed2c: 40 92 01 0c bne- cr4,ffc0ee38 <mq_open+0x168>
*/
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *
_POSIX_Message_queue_Allocate_fd( void )
{
return (POSIX_Message_queue_Control_fd *)
ffc0ed30: 3f a0 00 00 lis r29,0
ffc0ed34: 3b bd 36 18 addi r29,r29,13848
ffc0ed38: 7f a3 eb 78 mr r3,r29
ffc0ed3c: 48 00 3e 29 bl ffc12b64 <_Objects_Allocate>
attr = (struct mq_attr *) va_arg( arg, struct mq_attr * );
va_end(arg);
}
the_mq_fd = _POSIX_Message_queue_Allocate_fd();
if ( !the_mq_fd ) {
ffc0ed40: 7c 7f 1b 79 mr. r31,r3
ffc0ed44: 41 82 01 28 beq- ffc0ee6c <mq_open+0x19c> <== NEVER TAKEN
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENFILE );
}
the_mq_fd->oflag = oflag;
ffc0ed48: 93 df 00 14 stw r30,20(r31)
status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id );
ffc0ed4c: 7f 83 e3 78 mr r3,r28
ffc0ed50: 38 81 00 10 addi r4,r1,16
ffc0ed54: 48 00 92 49 bl ffc17f9c <_POSIX_Message_queue_Name_to_id>
* If the name to id translation worked, then the message queue exists
* and we can just return a pointer to the id. Otherwise we may
* need to check to see if this is a "message queue does not exist"
* or some other miscellaneous error on the name.
*/
if ( status ) {
ffc0ed58: 7c 7b 1b 79 mr. r27,r3
ffc0ed5c: 40 82 00 88 bne- ffc0ede4 <mq_open+0x114>
} else { /* name -> ID translation succeeded */
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
ffc0ed60: 73 de 0a 00 andi. r30,r30,2560
ffc0ed64: 2f 9e 0a 00 cmpwi cr7,r30,2560
ffc0ed68: 41 9e 01 48 beq- cr7,ffc0eeb0 <mq_open+0x1e0>
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control *_POSIX_Message_queue_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control *)
ffc0ed6c: 80 81 00 10 lwz r4,16(r1)
ffc0ed70: 3c 60 00 00 lis r3,0
ffc0ed74: 38 a1 00 08 addi r5,r1,8
ffc0ed78: 38 63 34 8c addi r3,r3,13452
ffc0ed7c: 48 00 43 d9 bl ffc13154 <_Objects_Get>
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
ffc0ed80: a0 1f 00 0a lhz r0,10(r31)
/*
* In this case we need to do an ID->pointer conversion to
* check the mode.
*/
the_mq = _POSIX_Message_queue_Get( the_mq_id, &location );
the_mq->open_count += 1;
ffc0ed84: 81 63 00 18 lwz r11,24(r3)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
ffc0ed88: 81 3d 00 1c lwz r9,28(r29)
ffc0ed8c: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc0ed90: 39 6b 00 01 addi r11,r11,1
/*
* In this case we need to do an ID->pointer conversion to
* check the mode.
*/
the_mq = _POSIX_Message_queue_Get( the_mq_id, &location );
ffc0ed94: 90 61 00 0c stw r3,12(r1)
the_mq->open_count += 1;
ffc0ed98: 91 63 00 18 stw r11,24(r3)
the_mq_fd->Queue = the_mq;
ffc0ed9c: 90 7f 00 10 stw r3,16(r31)
ffc0eda0: 7f e9 01 2e stwx r31,r9,r0
the_object
);
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
/* ASSERT: information->is_string */
the_object->name.name_p = name;
ffc0eda4: 93 7f 00 0c stw r27,12(r31)
_Objects_Open_string(
&_POSIX_Message_queue_Information_fds,
&the_mq_fd->Object,
NULL
);
_Thread_Enable_dispatch();
ffc0eda8: 48 00 55 4d bl ffc142f4 <_Thread_Enable_dispatch>
_Thread_Enable_dispatch();
ffc0edac: 48 00 55 49 bl ffc142f4 <_Thread_Enable_dispatch>
return (mqd_t)the_mq_fd->Object.id;
ffc0edb0: 80 7f 00 08 lwz r3,8(r31)
);
_Thread_Enable_dispatch();
return (mqd_t) the_mq_fd->Object.id;
}
ffc0edb4: 80 01 00 54 lwz r0,84(r1)
ffc0edb8: 81 81 00 34 lwz r12,52(r1)
ffc0edbc: 7c 08 03 a6 mtlr r0
ffc0edc0: 83 41 00 38 lwz r26,56(r1)
ffc0edc4: 83 61 00 3c lwz r27,60(r1)
ffc0edc8: 7d 80 81 20 mtcrf 8,r12
ffc0edcc: 83 81 00 40 lwz r28,64(r1)
ffc0edd0: 83 a1 00 44 lwz r29,68(r1)
ffc0edd4: 83 c1 00 48 lwz r30,72(r1)
ffc0edd8: 83 e1 00 4c lwz r31,76(r1)
ffc0eddc: 38 21 00 50 addi r1,r1,80
ffc0ede0: 4e 80 00 20 blr
if ( status ) {
/*
* 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) ) ) {
ffc0ede4: 2f 9b 00 02 cmpwi cr7,r27,2
ffc0ede8: 41 9e 01 18 beq- cr7,ffc0ef00 <mq_open+0x230>
RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free_fd (
POSIX_Message_queue_Control_fd *the_mq_fd
)
{
_Objects_Free( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object );
ffc0edec: 7f a3 eb 78 mr r3,r29
ffc0edf0: 7f e4 fb 78 mr r4,r31
ffc0edf4: 48 00 41 6d bl ffc12f60 <_Objects_Free>
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
ffc0edf8: 48 00 54 fd bl ffc142f4 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( status, mqd_t );
ffc0edfc: 48 00 d6 31 bl ffc1c42c <__errno>
);
_Thread_Enable_dispatch();
return (mqd_t) the_mq_fd->Object.id;
}
ffc0ee00: 80 01 00 54 lwz r0,84(r1)
ffc0ee04: 81 81 00 34 lwz r12,52(r1)
ffc0ee08: 7c 08 03 a6 mtlr r0
* and we are willing to create then it is an error.
*/
if ( !( status == ENOENT && (oflag & O_CREAT) ) ) {
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one_cast( status, mqd_t );
ffc0ee0c: 93 63 00 00 stw r27,0(r3)
);
_Thread_Enable_dispatch();
return (mqd_t) the_mq_fd->Object.id;
}
ffc0ee10: 7d 80 81 20 mtcrf 8,r12
* and we are willing to create then it is an error.
*/
if ( !( status == ENOENT && (oflag & O_CREAT) ) ) {
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one_cast( status, mqd_t );
ffc0ee14: 38 60 ff ff li r3,-1
);
_Thread_Enable_dispatch();
return (mqd_t) the_mq_fd->Object.id;
}
ffc0ee18: 83 41 00 38 lwz r26,56(r1)
ffc0ee1c: 83 61 00 3c lwz r27,60(r1)
ffc0ee20: 83 81 00 40 lwz r28,64(r1)
ffc0ee24: 83 a1 00 44 lwz r29,68(r1)
ffc0ee28: 83 c1 00 48 lwz r30,72(r1)
ffc0ee2c: 83 e1 00 4c lwz r31,76(r1)
ffc0ee30: 38 21 00 50 addi r1,r1,80
ffc0ee34: 4e 80 00 20 blr
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
ffc0ee38: 38 01 00 58 addi r0,r1,88
mode = (mode_t) va_arg( arg, unsigned int );
attr = (struct mq_attr *) va_arg( arg, struct mq_attr * );
ffc0ee3c: 83 41 00 2c lwz r26,44(r1)
*/
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *
_POSIX_Message_queue_Allocate_fd( void )
{
return (POSIX_Message_queue_Control_fd *)
ffc0ee40: 3f a0 00 00 lis r29,0
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
ffc0ee44: 90 01 00 18 stw r0,24(r1)
ffc0ee48: 3b bd 36 18 addi r29,r29,13848
ffc0ee4c: 38 01 00 20 addi r0,r1,32
ffc0ee50: 90 01 00 1c stw r0,28(r1)
ffc0ee54: 7f a3 eb 78 mr r3,r29
mode = (mode_t) va_arg( arg, unsigned int );
attr = (struct mq_attr *) va_arg( arg, struct mq_attr * );
ffc0ee58: 38 00 00 04 li r0,4
ffc0ee5c: 98 01 00 14 stb r0,20(r1)
ffc0ee60: 48 00 3d 05 bl ffc12b64 <_Objects_Allocate>
va_end(arg);
}
the_mq_fd = _POSIX_Message_queue_Allocate_fd();
if ( !the_mq_fd ) {
ffc0ee64: 7c 7f 1b 79 mr. r31,r3
ffc0ee68: 40 82 fe e0 bne+ ffc0ed48 <mq_open+0x78>
_Thread_Enable_dispatch();
ffc0ee6c: 48 00 54 89 bl ffc142f4 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENFILE );
ffc0ee70: 48 00 d5 bd bl ffc1c42c <__errno>
ffc0ee74: 38 00 00 17 li r0,23
ffc0ee78: 90 03 00 00 stw r0,0(r3)
ffc0ee7c: 38 60 ff ff li r3,-1
);
_Thread_Enable_dispatch();
return (mqd_t) the_mq_fd->Object.id;
}
ffc0ee80: 80 01 00 54 lwz r0,84(r1)
ffc0ee84: 81 81 00 34 lwz r12,52(r1)
ffc0ee88: 7c 08 03 a6 mtlr r0
ffc0ee8c: 83 41 00 38 lwz r26,56(r1)
ffc0ee90: 83 61 00 3c lwz r27,60(r1)
ffc0ee94: 7d 80 81 20 mtcrf 8,r12
ffc0ee98: 83 81 00 40 lwz r28,64(r1)
ffc0ee9c: 83 a1 00 44 lwz r29,68(r1)
ffc0eea0: 83 c1 00 48 lwz r30,72(r1)
ffc0eea4: 83 e1 00 4c lwz r31,76(r1)
ffc0eea8: 38 21 00 50 addi r1,r1,80
ffc0eeac: 4e 80 00 20 blr
RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free_fd (
POSIX_Message_queue_Control_fd *the_mq_fd
)
{
_Objects_Free( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object );
ffc0eeb0: 7f a3 eb 78 mr r3,r29
ffc0eeb4: 7f e4 fb 78 mr r4,r31
ffc0eeb8: 48 00 40 a9 bl ffc12f60 <_Objects_Free>
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
ffc0eebc: 48 00 54 39 bl ffc142f4 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( EEXIST, mqd_t );
ffc0eec0: 48 00 d5 6d bl ffc1c42c <__errno>
ffc0eec4: 38 00 00 11 li r0,17
ffc0eec8: 90 03 00 00 stw r0,0(r3)
ffc0eecc: 38 60 ff ff li r3,-1
);
_Thread_Enable_dispatch();
return (mqd_t) the_mq_fd->Object.id;
}
ffc0eed0: 80 01 00 54 lwz r0,84(r1)
ffc0eed4: 81 81 00 34 lwz r12,52(r1)
ffc0eed8: 7c 08 03 a6 mtlr r0
ffc0eedc: 83 41 00 38 lwz r26,56(r1)
ffc0eee0: 83 61 00 3c lwz r27,60(r1)
ffc0eee4: 7d 80 81 20 mtcrf 8,r12
ffc0eee8: 83 81 00 40 lwz r28,64(r1)
ffc0eeec: 83 a1 00 44 lwz r29,68(r1)
ffc0eef0: 83 c1 00 48 lwz r30,72(r1)
ffc0eef4: 83 e1 00 4c lwz r31,76(r1)
ffc0eef8: 38 21 00 50 addi r1,r1,80
ffc0eefc: 4e 80 00 20 blr
if ( status ) {
/*
* 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) ) ) {
ffc0ef00: 41 92 fe ec beq+ cr4,ffc0edec <mq_open+0x11c>
/*
* At this point, the message queue does not exist and everything has been
* checked. We should go ahead and create a message queue.
*/
status = _POSIX_Message_queue_Create_support(
ffc0ef04: 7f 83 e3 78 mr r3,r28
ffc0ef08: 38 80 00 01 li r4,1
ffc0ef0c: 7f 45 d3 78 mr r5,r26
ffc0ef10: 38 c1 00 0c addi r6,r1,12
ffc0ef14: 48 00 8e bd bl ffc17dd0 <_POSIX_Message_queue_Create_support>
);
/*
* errno was set by Create_support, so don't set it again.
*/
if ( status == -1 ) {
ffc0ef18: 2f 83 ff ff cmpwi cr7,r3,-1
ffc0ef1c: 41 9e 00 30 beq- cr7,ffc0ef4c <mq_open+0x27c>
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
ffc0ef20: a0 1f 00 0a lhz r0,10(r31)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
ffc0ef24: 81 3d 00 1c lwz r9,28(r29)
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
return (mqd_t) -1;
}
the_mq_fd->Queue = the_mq;
ffc0ef28: 81 61 00 0c lwz r11,12(r1)
ffc0ef2c: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc0ef30: 91 7f 00 10 stw r11,16(r31)
ffc0ef34: 7f e9 01 2e stwx r31,r9,r0
the_object
);
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
/* ASSERT: information->is_string */
the_object->name.name_p = name;
ffc0ef38: 38 00 00 00 li r0,0
ffc0ef3c: 90 1f 00 0c stw r0,12(r31)
&_POSIX_Message_queue_Information_fds,
&the_mq_fd->Object,
NULL
);
_Thread_Enable_dispatch();
ffc0ef40: 48 00 53 b5 bl ffc142f4 <_Thread_Enable_dispatch>
return (mqd_t) the_mq_fd->Object.id;
ffc0ef44: 80 7f 00 08 lwz r3,8(r31)
ffc0ef48: 4b ff fe 6c b ffc0edb4 <mq_open+0xe4>
ffc0ef4c: 7f a3 eb 78 mr r3,r29
ffc0ef50: 7f e4 fb 78 mr r4,r31
ffc0ef54: 48 00 40 0d bl ffc12f60 <_Objects_Free>
/*
* errno was set by Create_support, so don't set it again.
*/
if ( status == -1 ) {
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
ffc0ef58: 48 00 53 9d bl ffc142f4 <_Thread_Enable_dispatch>
return (mqd_t) -1;
ffc0ef5c: 38 60 ff ff li r3,-1
ffc0ef60: 4b ff fe 54 b ffc0edb4 <mq_open+0xe4>
ffc1e4d0 <msdos_creat_node>:
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
ffc1e4d0: 94 21 ff 28 stwu r1,-216(r1)
ffc1e4d4: 7c 08 02 a6 mflr r0
ffc1e4d8: 7d 80 00 26 mfcr r12
ffc1e4dc: 90 01 00 dc stw r0,220(r1)
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
ffc1e4e0: 38 00 ff ff li r0,-1
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
ffc1e4e4: 81 23 00 10 lwz r9,16(r3)
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
ffc1e4e8: 93 21 00 bc stw r25,188(r1)
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
fat_file_fd_t *parent_fat_fd = parent_loc->node_access;
fat_file_fd_t *fat_fd = NULL;
ffc1e4ec: 3b 20 00 00 li r25,0
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
ffc1e4f0: 93 41 00 c0 stw r26,192(r1)
ffc1e4f4: 7c ba 2b 78 mr r26,r5
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
ffc1e4f8: 38 a0 00 40 li r5,64
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
ffc1e4fc: 93 61 00 c4 stw r27,196(r1)
ffc1e500: 7c db 33 78 mr r27,r6
ffc1e504: 93 c1 00 d0 stw r30,208(r1)
ffc1e508: 7c 9e 23 78 mr r30,r4
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
ffc1e50c: 38 80 00 00 li r4,0
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
ffc1e510: 93 e1 00 d4 stw r31,212(r1)
ffc1e514: 7c 7f 1b 78 mr r31,r3
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
ffc1e518: 38 61 00 60 addi r3,r1,96
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
ffc1e51c: 91 81 00 ac stw r12,172(r1)
ffc1e520: 90 01 00 18 stw r0,24(r1)
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
ffc1e524: 90 01 00 1c stw r0,28(r1)
ffc1e528: 92 c1 00 b0 stw r22,176(r1)
*MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE;
/* set up last write date and time */
time_ret = time(NULL);
if ( time_ret == -1 )
return -1;
ffc1e52c: 3a c0 ff ff li r22,-1
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
ffc1e530: 92 e1 00 b4 stw r23,180(r1)
ffc1e534: 7d 17 43 78 mr r23,r8
ffc1e538: 93 01 00 b8 stw r24,184(r1)
ffc1e53c: 93 81 00 c8 stw r28,200(r1)
ffc1e540: 93 a1 00 cc stw r29,204(r1)
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
fat_file_fd_t *parent_fat_fd = parent_loc->node_access;
ffc1e544: 83 9f 00 00 lwz r28,0(r31)
mode_t mode,
const fat_file_fd_t *link_fd)
{
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
ffc1e548: 83 a9 00 34 lwz r29,52(r9)
fat_file_fd_t *parent_fat_fd = parent_loc->node_access;
fat_file_fd_t *fat_fd = NULL;
ffc1e54c: 93 21 00 0c stw r25,12(r1)
time_t time_ret = 0;
uint16_t time_val = 0;
ffc1e550: b3 21 00 0a sth r25,10(r1)
uint16_t date = 0;
ffc1e554: b3 21 00 08 sth r25,8(r1)
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
ffc1e558: 93 21 00 10 stw r25,16(r1)
dir_pos->sname.ofs = 0;
ffc1e55c: 93 21 00 14 stw r25,20(r1)
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
ffc1e560: 93 21 00 40 stw r25,64(r1)
ffc1e564: 93 21 00 44 stw r25,68(r1)
ffc1e568: 93 21 00 48 stw r25,72(r1)
ffc1e56c: 93 21 00 4c stw r25,76(r1)
ffc1e570: 93 21 00 50 stw r25,80(r1)
ffc1e574: 93 21 00 54 stw r25,84(r1)
ffc1e578: 93 21 00 58 stw r25,88(r1)
ffc1e57c: 93 21 00 5c stw r25,92(r1)
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
ffc1e580: 48 00 6b a9 bl ffc25128 <memset>
name_type = msdos_long_to_short (name, name_len,
ffc1e584: 7f 64 db 78 mr r4,r27
ffc1e588: 38 a1 00 40 addi r5,r1,64
ffc1e58c: 38 c0 00 0b li r6,11
ffc1e590: 7f 43 d3 78 mr r3,r26
ffc1e594: 48 00 13 e5 bl ffc1f978 <msdos_long_to_short>
MSDOS_DIR_NAME(short_node),
MSDOS_NAME_MAX);
/* fill reserved field */
*MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE;
ffc1e598: 38 00 00 00 li r0,0
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
name_type = msdos_long_to_short (name, name_len,
ffc1e59c: 7c 78 1b 78 mr r24,r3
MSDOS_DIR_NAME(short_node),
MSDOS_NAME_MAX);
/* fill reserved field */
*MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE;
ffc1e5a0: 98 01 00 4c stb r0,76(r1)
/* set up last write date and time */
time_ret = time(NULL);
ffc1e5a4: 38 60 00 00 li r3,0
ffc1e5a8: 48 00 a4 29 bl ffc289d0 <time>
if ( time_ret == -1 )
ffc1e5ac: 2f 83 ff ff cmpwi cr7,r3,-1
ffc1e5b0: 41 9e 00 90 beq- cr7,ffc1e640 <msdos_creat_node+0x170> <== NEVER TAKEN
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
ffc1e5b4: 38 81 00 08 addi r4,r1,8
ffc1e5b8: 38 a1 00 0a addi r5,r1,10
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
if (type == MSDOS_DIRECTORY) {
ffc1e5bc: 2e 1e 00 01 cmpwi cr4,r30,1
/* set up last write date and time */
time_ret = time(NULL);
if ( time_ret == -1 )
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
ffc1e5c0: 48 00 4c f5 bl ffc232b4 <msdos_date_unix2dos>
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
ffc1e5c4: a0 01 00 0a lhz r0,10(r1)
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
ffc1e5c8: a1 61 00 08 lhz r11,8(r1)
time_ret = time(NULL);
if ( time_ret == -1 )
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
ffc1e5cc: 54 0a c2 3e rlwinm r10,r0,24,8,31
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
*MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
ffc1e5d0: 93 21 00 5c stw r25,92(r1)
time_ret = time(NULL);
if ( time_ret == -1 )
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
ffc1e5d4: 54 09 44 2e rlwinm r9,r0,8,16,23
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
ffc1e5d8: 55 68 c2 3e rlwinm r8,r11,24,8,31
ffc1e5dc: 55 60 44 2e rlwinm r0,r11,8,16,23
ffc1e5e0: 7c 00 43 78 or r0,r0,r8
time_ret = time(NULL);
if ( time_ret == -1 )
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
ffc1e5e4: 7d 29 53 78 or r9,r9,r10
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
ffc1e5e8: b0 01 00 50 sth r0,80(r1)
time_ret = time(NULL);
if ( time_ret == -1 )
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
ffc1e5ec: b1 21 00 4e sth r9,78(r1)
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
ffc1e5f0: b1 21 00 56 sth r9,86(r1)
*MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);
ffc1e5f4: b0 01 00 58 sth r0,88(r1)
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
ffc1e5f8: b0 01 00 52 sth r0,82(r1)
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
if (type == MSDOS_DIRECTORY) {
ffc1e5fc: 41 92 00 88 beq- cr4,ffc1e684 <msdos_creat_node+0x1b4>
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
}
else if (type == MSDOS_HARD_LINK) {
ffc1e600: 2f 9e 00 03 cmpwi cr7,r30,3
ffc1e604: 41 9e 00 90 beq- cr7,ffc1e694 <msdos_creat_node+0x1c4> <== NEVER TAKEN
* set "archive bit" due to changes
*/
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
}
else { /* regular file... */
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
ffc1e608: 88 01 00 4b lbz r0,75(r1)
ffc1e60c: 60 00 00 20 ori r0,r0,32
ffc1e610: 98 01 00 4b stb r0,75(r1)
/*
* find free space in the parent directory and write new initialized
* FAT 32 Bytes Directory Entry Structure to the disk
*/
rc = msdos_get_name_node(parent_loc, true, name, name_len,
ffc1e614: 7f e3 fb 78 mr r3,r31
ffc1e618: 38 80 00 01 li r4,1
ffc1e61c: 7f 45 d3 78 mr r5,r26
ffc1e620: 7f 66 db 78 mr r6,r27
ffc1e624: 7f 07 c3 78 mr r7,r24
ffc1e628: 39 01 00 10 addi r8,r1,16
ffc1e62c: 39 21 00 40 addi r9,r1,64
ffc1e630: 48 00 2d 79 bl ffc213a8 <msdos_get_name_node>
name_type, &dir_pos, short_node);
if ( rc != RC_OK )
ffc1e634: 7c 76 1b 79 mr. r22,r3
ffc1e638: 40 82 00 08 bne- ffc1e640 <msdos_creat_node+0x170> <== NEVER TAKEN
/*
* if we create a new file we are done, if directory there are more steps
* to do
*/
if (type == MSDOS_DIRECTORY)
ffc1e63c: 41 92 01 00 beq- cr4,ffc1e73c <msdos_creat_node+0x26c>
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
ffc1e640: 80 01 00 dc lwz r0,220(r1)
ffc1e644: 7e c3 b3 78 mr r3,r22
ffc1e648: 81 81 00 ac lwz r12,172(r1)
ffc1e64c: 7c 08 03 a6 mtlr r0
ffc1e650: 82 c1 00 b0 lwz r22,176(r1)
ffc1e654: 82 e1 00 b4 lwz r23,180(r1)
ffc1e658: 7d 80 81 20 mtcrf 8,r12
ffc1e65c: 83 01 00 b8 lwz r24,184(r1)
ffc1e660: 83 21 00 bc lwz r25,188(r1)
ffc1e664: 83 41 00 c0 lwz r26,192(r1)
ffc1e668: 83 61 00 c4 lwz r27,196(r1)
ffc1e66c: 83 81 00 c8 lwz r28,200(r1)
ffc1e670: 83 a1 00 cc lwz r29,204(r1)
ffc1e674: 83 c1 00 d0 lwz r30,208(r1)
ffc1e678: 83 e1 00 d4 lwz r31,212(r1)
ffc1e67c: 38 21 00 d8 addi r1,r1,216
ffc1e680: 4e 80 00 20 blr
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
if (type == MSDOS_DIRECTORY) {
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
ffc1e684: 88 01 00 4b lbz r0,75(r1)
ffc1e688: 60 00 00 10 ori r0,r0,16
ffc1e68c: 98 01 00 4b stb r0,75(r1)
ffc1e690: 4b ff ff 84 b ffc1e614 <msdos_creat_node+0x144>
* node to the newly created
*/
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(parent_loc->mt_entry,
ffc1e694: 81 77 00 20 lwz r11,32(r23) <== NOT EXECUTED
ffc1e698: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
ffc1e69c: 2f 8b 00 00 cmpwi cr7,r11,0 <== NOT EXECUTED
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
ffc1e6a0: 81 23 00 34 lwz r9,52(r3) <== NOT EXECUTED
ffc1e6a4: 40 9e 00 10 bne- cr7,ffc1e6b4 <msdos_creat_node+0x1e4> <== NOT EXECUTED
ffc1e6a8: 88 09 00 0a lbz r0,10(r9) <== NOT EXECUTED
ffc1e6ac: 70 0a 00 03 andi. r10,r0,3 <== NOT EXECUTED
ffc1e6b0: 40 82 02 4c bne- ffc1e8fc <msdos_creat_node+0x42c> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
ffc1e6b4: 89 49 00 05 lbz r10,5(r9) <== NOT EXECUTED
ffc1e6b8: 38 8b ff fe addi r4,r11,-2 <== NOT EXECUTED
ffc1e6bc: 80 09 00 30 lwz r0,48(r9) <== NOT EXECUTED
ffc1e6c0: 7c 84 50 30 slw r4,r4,r10 <== NOT EXECUTED
ffc1e6c4: 7c 84 02 14 add r4,r4,r0 <== NOT EXECUTED
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(parent_loc->mt_entry,
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
ffc1e6c8: 80 17 00 24 lwz r0,36(r23) <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
ret = _fat_block_read(parent_loc->mt_entry,
ffc1e6cc: 38 c0 00 20 li r6,32 <== NOT EXECUTED
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(parent_loc->mt_entry,
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
ffc1e6d0: 89 3d 00 02 lbz r9,2(r29) <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
ret = _fat_block_read(parent_loc->mt_entry,
ffc1e6d4: 38 e1 00 20 addi r7,r1,32 <== NOT EXECUTED
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(parent_loc->mt_entry,
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
ffc1e6d8: a0 bd 00 00 lhz r5,0(r29) <== NOT EXECUTED
ret = _fat_block_read(parent_loc->mt_entry,
sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
link_node);
if (ret < 0) {
return -1;
ffc1e6dc: 3a c0 ff ff li r22,-1 <== NOT EXECUTED
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(parent_loc->mt_entry,
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
ffc1e6e0: 7c 09 4c 30 srw r9,r0,r9 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
ffc1e6e4: 38 a5 ff ff addi r5,r5,-1 <== NOT EXECUTED
ret = _fat_block_read(parent_loc->mt_entry,
ffc1e6e8: 7c 84 4a 14 add r4,r4,r9 <== NOT EXECUTED
ffc1e6ec: 7c a5 00 38 and r5,r5,r0 <== NOT EXECUTED
ffc1e6f0: 4b ff 9f b5 bl ffc186a4 <_fat_block_read> <== NOT EXECUTED
sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
link_node);
if (ret < 0) {
ffc1e6f4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1e6f8: 41 bc ff 48 blt- cr7,ffc1e640 <msdos_creat_node+0x170> <== NOT EXECUTED
return -1;
}
/*
* copy various attributes
*/
*MSDOS_DIR_ATTR(short_node) =*MSDOS_DIR_ATTR(link_node);
ffc1e6fc: 88 01 00 2b lbz r0,43(r1) <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
ffc1e700: 88 c1 00 2d lbz r6,45(r1) <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME(short_node) =*MSDOS_DIR_CRT_TIME(link_node);
ffc1e704: a0 e1 00 2e lhz r7,46(r1) <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
*MSDOS_DIR_FIRST_CLUSTER_HI(link_node);
/*
* set "archive bit" due to changes
*/
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
ffc1e708: 60 00 00 20 ori r0,r0,32 <== NOT EXECUTED
* copy various attributes
*/
*MSDOS_DIR_ATTR(short_node) =*MSDOS_DIR_ATTR(link_node);
*MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
*MSDOS_DIR_CRT_TIME(short_node) =*MSDOS_DIR_CRT_TIME(link_node);
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
ffc1e70c: a1 01 00 30 lhz r8,48(r1) <== NOT EXECUTED
/*
* copy/set "file size", "first cluster"
*/
*MSDOS_DIR_FILE_SIZE(short_node) =*MSDOS_DIR_FILE_SIZE(link_node);
ffc1e710: 81 41 00 3c lwz r10,60(r1) <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =
ffc1e714: a1 61 00 3a lhz r11,58(r1) <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(link_node);
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
ffc1e718: a1 21 00 34 lhz r9,52(r1) <== NOT EXECUTED
}
/*
* copy various attributes
*/
*MSDOS_DIR_ATTR(short_node) =*MSDOS_DIR_ATTR(link_node);
*MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
ffc1e71c: 98 c1 00 4d stb r6,77(r1) <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME(short_node) =*MSDOS_DIR_CRT_TIME(link_node);
ffc1e720: b0 e1 00 4e sth r7,78(r1) <== NOT EXECUTED
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
ffc1e724: b1 01 00 50 sth r8,80(r1) <== NOT EXECUTED
/*
* copy/set "file size", "first cluster"
*/
*MSDOS_DIR_FILE_SIZE(short_node) =*MSDOS_DIR_FILE_SIZE(link_node);
ffc1e728: 91 41 00 5c stw r10,92(r1) <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =
ffc1e72c: b1 61 00 5a sth r11,90(r1) <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(link_node);
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
ffc1e730: b1 21 00 54 sth r9,84(r1) <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(link_node);
/*
* set "archive bit" due to changes
*/
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
ffc1e734: 98 01 00 4b stb r0,75(r1) <== NOT EXECUTED
ffc1e738: 4b ff fe dc b ffc1e614 <msdos_creat_node+0x144> <== NOT EXECUTED
* to do
*/
if (type == MSDOS_DIRECTORY)
{
/* open new directory as fat-file */
rc = fat_file_open(parent_loc->mt_entry, &dir_pos, &fat_fd);
ffc1e73c: 80 7f 00 10 lwz r3,16(r31)
ffc1e740: 38 81 00 10 addi r4,r1,16
ffc1e744: 38 a1 00 0c addi r5,r1,12
ffc1e748: 4b ff 8a 55 bl ffc1719c <fat_file_open>
if (rc != RC_OK)
ffc1e74c: 7c 76 1b 79 mr. r22,r3
ffc1e750: 40 82 01 98 bne- ffc1e8e8 <msdos_creat_node+0x418> <== NEVER TAKEN
/*
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
ffc1e754: 80 81 00 0c lwz r4,12(r1)
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
ffc1e758: 3c 00 00 20 lis r0,32
/*
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
ffc1e75c: 92 c4 00 18 stw r22,24(r4)
fat_fd->fat_file_type = FAT_DIRECTORY;
ffc1e760: 93 c4 00 10 stw r30,16(r4)
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
ffc1e764: 90 04 00 14 stw r0,20(r4)
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
ffc1e768: 81 21 00 58 lwz r9,88(r1)
ffc1e76c: 81 01 00 4c lwz r8,76(r1)
ffc1e770: 81 41 00 50 lwz r10,80(r1)
ffc1e774: 81 61 00 54 lwz r11,84(r1)
ffc1e778: 80 01 00 5c lwz r0,92(r1)
ffc1e77c: 80 a1 00 40 lwz r5,64(r1)
ffc1e780: 80 c1 00 44 lwz r6,68(r1)
ffc1e784: 80 e1 00 48 lwz r7,72(r1)
ffc1e788: 91 21 00 78 stw r9,120(r1)
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
ffc1e78c: 91 21 00 98 stw r9,152(r1)
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
ffc1e790: 3d 20 00 00 lis r9,0
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
ffc1e794: 91 01 00 6c stw r8,108(r1)
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
ffc1e798: 91 01 00 8c stw r8,140(r1)
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
ffc1e79c: 90 a1 00 60 stw r5,96(r1)
ffc1e7a0: 90 c1 00 64 stw r6,100(r1)
ffc1e7a4: 90 e1 00 68 stw r7,104(r1)
ffc1e7a8: 91 41 00 70 stw r10,112(r1)
ffc1e7ac: 91 61 00 74 stw r11,116(r1)
ffc1e7b0: 90 01 00 7c stw r0,124(r1)
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
ffc1e7b4: 90 a1 00 80 stw r5,128(r1)
ffc1e7b8: 90 c1 00 84 stw r6,132(r1)
ffc1e7bc: 90 e1 00 88 stw r7,136(r1)
ffc1e7c0: 91 41 00 90 stw r10,144(r1)
ffc1e7c4: 91 61 00 94 stw r11,148(r1)
ffc1e7c8: 90 01 00 9c stw r0,156(r1)
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
ffc1e7cc: 81 29 27 e8 lwz r9,10216(r9)
ffc1e7d0: 81 49 00 04 lwz r10,4(r9)
ffc1e7d4: a1 69 00 08 lhz r11,8(r9)
ffc1e7d8: 88 09 00 0a lbz r0,10(r9)
ffc1e7dc: 81 29 00 00 lwz r9,0(r9)
ffc1e7e0: 91 21 00 60 stw r9,96(r1)
MSDOS_NAME_MAX);
memcpy(MSDOS_DIR_NAME(DOTDOT_NODE_P(dot_dotdot)), MSDOS_DOTDOT_NAME,
ffc1e7e4: 3d 20 00 00 lis r9,0
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
ffc1e7e8: 91 41 00 64 stw r10,100(r1)
ffc1e7ec: b1 61 00 68 sth r11,104(r1)
ffc1e7f0: 98 01 00 6a stb r0,106(r1)
MSDOS_NAME_MAX);
memcpy(MSDOS_DIR_NAME(DOTDOT_NODE_P(dot_dotdot)), MSDOS_DOTDOT_NAME,
ffc1e7f4: 81 29 27 e4 lwz r9,10212(r9)
ffc1e7f8: 88 09 00 0a lbz r0,10(r9)
ffc1e7fc: 81 09 00 00 lwz r8,0(r9)
ffc1e800: 81 49 00 04 lwz r10,4(r9)
ffc1e804: a1 69 00 08 lhz r11,8(r9)
ffc1e808: 91 01 00 80 stw r8,128(r1)
ffc1e80c: 91 41 00 84 stw r10,132(r1)
ffc1e810: b1 61 00 88 sth r11,136(r1)
ffc1e814: 98 01 00 8a stb r0,138(r1)
/*
* here we can ommit FAT32 condition because for all FAT types dirs
* right under root dir should contain 0 in dotdot entry but for
* FAT12/16 parent_fat_fd->cluster_num always contains such value
*/
if ((FAT_FD_OF_ROOT_DIR(parent_fat_fd)) &&
ffc1e818: 80 1c 00 20 lwz r0,32(r28)
ffc1e81c: 2f 80 00 01 cmpwi cr7,r0,1
ffc1e820: 41 9e 00 e4 beq- cr7,ffc1e904 <msdos_creat_node+0x434>
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
ffc1e824: 80 1c 00 1c lwz r0,28(r28)
ffc1e828: 54 09 04 3e clrlwi r9,r0,16
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((parent_fat_fd->cln) & 0xFFFF0000)>>16));
ffc1e82c: 54 00 84 3e rlwinm r0,r0,16,16,31
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
ffc1e830: 55 2a 40 2e rlwinm r10,r9,8,0,23
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((parent_fat_fd->cln) & 0xFFFF0000)>>16));
ffc1e834: 54 0b 40 2e rlwinm r11,r0,8,0,23
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
ffc1e838: 55 29 c2 3e rlwinm r9,r9,24,8,31
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
ffc1e83c: 54 00 c2 3e rlwinm r0,r0,24,8,31
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
ffc1e840: 7d 49 4b 78 or r9,r10,r9
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
ffc1e844: 7d 60 03 78 or r0,r11,r0
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
ffc1e848: b1 21 00 9a sth r9,154(r1)
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
ffc1e84c: b0 01 00 94 sth r0,148(r1)
/*
* write dot and dotdot entries to new fat-file: currently fat-file
* correspondes to a new node is zero length, so it will be extended
* by one cluster and entries will be written
*/
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
ffc1e850: 80 7f 00 10 lwz r3,16(r31)
ffc1e854: 38 a0 00 00 li r5,0
ffc1e858: 38 c0 00 40 li r6,64
ffc1e85c: 38 e1 00 60 addi r7,r1,96
ffc1e860: 4b ff 94 61 bl ffc17cc0 <fat_file_write>
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,
(uint8_t *)dot_dotdot);
if (ret < 0)
ffc1e864: 2f 83 00 00 cmpwi cr7,r3,0
ffc1e868: 41 9c 00 c0 blt- cr7,ffc1e928 <msdos_creat_node+0x458> <== NEVER TAKEN
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
ffc1e86c: 80 81 00 0c lwz r4,12(r1)
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
/* rewrite dot entry */
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
ffc1e870: 38 a0 00 00 li r5,0
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
ffc1e874: a1 3d 00 06 lhz r9,6(r29)
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
/* rewrite dot entry */
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
ffc1e878: 38 c0 00 20 li r6,32
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
ffc1e87c: 81 64 00 18 lwz r11,24(r4)
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
/* rewrite dot entry */
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
ffc1e880: 38 e1 00 60 addi r7,r1,96
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
ffc1e884: 80 04 00 1c lwz r0,28(r4)
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
ffc1e888: 7d 6b 4a 14 add r11,r11,r9
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
/* rewrite dot entry */
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
ffc1e88c: 80 7f 00 10 lwz r3,16(r31)
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
ffc1e890: 54 09 04 3e clrlwi r9,r0,16
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
ffc1e894: 91 64 00 18 stw r11,24(r4)
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
ffc1e898: 54 00 84 3e rlwinm r0,r0,16,16,31
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
ffc1e89c: 55 2a 40 2e rlwinm r10,r9,8,0,23
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
ffc1e8a0: 54 0b 40 2e rlwinm r11,r0,8,0,23
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
ffc1e8a4: 55 29 c2 3e rlwinm r9,r9,24,8,31
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
ffc1e8a8: 54 00 c2 3e rlwinm r0,r0,24,8,31
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
ffc1e8ac: 7d 49 4b 78 or r9,r10,r9
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
ffc1e8b0: 7d 60 03 78 or r0,r11,r0
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
ffc1e8b4: b1 21 00 7a sth r9,122(r1)
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
ffc1e8b8: b0 01 00 74 sth r0,116(r1)
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
/* rewrite dot entry */
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
ffc1e8bc: 4b ff 94 05 bl ffc17cc0 <fat_file_write>
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
(uint8_t *)DOT_NODE_P(dot_dotdot));
if (ret < 0)
ffc1e8c0: 2f 83 00 00 cmpwi cr7,r3,0
ffc1e8c4: 41 9c 00 64 blt- cr7,ffc1e928 <msdos_creat_node+0x458> <== NEVER TAKEN
rc = -1;
goto error;
}
/* write first cluster num of a new directory to disk */
rc = msdos_set_first_cluster_num(parent_loc->mt_entry, fat_fd);
ffc1e8c8: 80 7f 00 10 lwz r3,16(r31)
ffc1e8cc: 80 81 00 0c lwz r4,12(r1)
ffc1e8d0: 48 00 15 a1 bl ffc1fe70 <msdos_set_first_cluster_num>
if (rc != RC_OK)
ffc1e8d4: 7c 76 1b 79 mr. r22,r3
ffc1e8d8: 41 82 00 58 beq- ffc1e930 <msdos_creat_node+0x460> <== ALWAYS TAKEN
fat_file_close(parent_loc->mt_entry, fat_fd);
}
return RC_OK;
error:
fat_file_close(parent_loc->mt_entry, fat_fd);
ffc1e8dc: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc1e8e0: 80 81 00 0c lwz r4,12(r1) <== NOT EXECUTED
ffc1e8e4: 4b ff 8f 9d bl ffc17880 <fat_file_close> <== NOT EXECUTED
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
ffc1e8e8: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc1e8ec: 38 81 00 10 addi r4,r1,16 <== NOT EXECUTED
ffc1e8f0: 38 a0 00 e5 li r5,229 <== NOT EXECUTED
ffc1e8f4: 48 00 17 35 bl ffc20028 <msdos_set_first_char4file_name><== NOT EXECUTED
return rc;
ffc1e8f8: 4b ff fd 48 b ffc1e640 <msdos_creat_node+0x170> <== NOT EXECUTED
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
return fs_info->vol.rdir_loc;
ffc1e8fc: 80 89 00 1c lwz r4,28(r9) <== NOT EXECUTED
ffc1e900: 4b ff fd c8 b ffc1e6c8 <msdos_creat_node+0x1f8> <== NOT EXECUTED
/*
* here we can ommit FAT32 condition because for all FAT types dirs
* right under root dir should contain 0 in dotdot entry but for
* FAT12/16 parent_fat_fd->cluster_num always contains such value
*/
if ((FAT_FD_OF_ROOT_DIR(parent_fat_fd)) &&
ffc1e904: 80 1c 00 24 lwz r0,36(r28)
ffc1e908: 2f 80 00 00 cmpwi cr7,r0,0
ffc1e90c: 40 be ff 18 bne- cr7,ffc1e824 <msdos_creat_node+0x354> <== NEVER TAKEN
(fs_info->fat.vol.type & FAT_FAT32))
ffc1e910: 89 3d 00 0a lbz r9,10(r29)
/*
* here we can ommit FAT32 condition because for all FAT types dirs
* right under root dir should contain 0 in dotdot entry but for
* FAT12/16 parent_fat_fd->cluster_num always contains such value
*/
if ((FAT_FD_OF_ROOT_DIR(parent_fat_fd)) &&
ffc1e914: 71 2b 00 04 andi. r11,r9,4
ffc1e918: 41 a2 ff 0c beq- ffc1e824 <msdos_creat_node+0x354> <== ALWAYS TAKEN
(fs_info->fat.vol.type & FAT_FAT32))
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
ffc1e91c: b0 01 00 9a sth r0,154(r1) <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
ffc1e920: b0 01 00 94 sth r0,148(r1) <== NOT EXECUTED
ffc1e924: 4b ff ff 2c b ffc1e850 <msdos_creat_node+0x380> <== NOT EXECUTED
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
(uint8_t *)DOT_NODE_P(dot_dotdot));
if (ret < 0)
{
rc = -1;
ffc1e928: 3a c0 ff ff li r22,-1 <== NOT EXECUTED
ffc1e92c: 4b ff ff b0 b ffc1e8dc <msdos_creat_node+0x40c> <== NOT EXECUTED
/* write first cluster num of a new directory to disk */
rc = msdos_set_first_cluster_num(parent_loc->mt_entry, fat_fd);
if (rc != RC_OK)
goto error;
fat_file_close(parent_loc->mt_entry, fat_fd);
ffc1e930: 80 7f 00 10 lwz r3,16(r31)
ffc1e934: 80 81 00 0c lwz r4,12(r1)
ffc1e938: 4b ff 8f 49 bl ffc17880 <fat_file_close>
ffc1e93c: 4b ff fd 04 b ffc1e640 <msdos_creat_node+0x170>
ffc2342c <msdos_date_dos2unix>:
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
ffc2342c: 3d 20 00 00 lis r9,0
ffc23430: 39 29 2a fc addi r9,r9,11004
ffc23434: a0 09 00 0c lhz r0,12(r9)
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
ffc23438: 54 8b ae fe rlwinm r11,r4,21,27,31
uint32_t y, year;
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
ffc2343c: 54 8a de be rlwinm r10,r4,27,26,31
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
ffc23440: 7f 80 18 00 cmpw cr7,r0,r3
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
ffc23444: 1d 6b 07 08 mulli r11,r11,1800
uint32_t y, year;
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
ffc23448: 1c 0a 00 1e mulli r0,r10,30
uint32_t m, month;
uint32_t y, year;
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
ffc2344c: 54 84 06 fe clrlwi r4,r4,27
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
ffc23450: 7c 0b 02 14 add r0,r11,r0
ffc23454: 7c 80 22 14 add r4,r0,r4
uint32_t m, month;
uint32_t y, year;
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
ffc23458: 54 84 08 3c rlwinm r4,r4,1,0,30
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
ffc2345c: 41 9e 00 bc beq- cr7,ffc23518 <msdos_date_dos2unix+0xec>
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
ffc23460: 54 68 be 7f rlwinm. r8,r3,23,25,31
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
lastdosdate = dd;
ffc23464: b0 69 00 0c sth r3,12(r9)
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
ffc23468: 38 00 00 00 li r0,0
ffc2346c: 41 82 00 b8 beq- ffc23524 <msdos_date_dos2unix+0xf8> <== NEVER TAKEN
ffc23470: 39 60 00 00 li r11,0
ffc23474: 7d 09 03 a6 mtctr r8
ffc23478: 39 40 01 6e li r10,366
ffc2347c: 48 00 00 10 b ffc2348c <msdos_date_dos2unix+0x60>
days += y & 0x03 ? 365 : 366;
ffc23480: 7d 40 00 26 mfcr r10
ffc23484: 55 4a 1f fe rlwinm r10,r10,3,31,31
ffc23488: 39 4a 01 6d addi r10,r10,365
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
ffc2348c: 39 6b 00 01 addi r11,r11,1
days += y & 0x03 ? 365 : 366;
ffc23490: 7c 00 52 14 add r0,r0,r10
ffc23494: 71 6a 00 03 andi. r10,r11,3
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
ffc23498: 42 00 ff e8 bdnz+ ffc23480 <msdos_date_dos2unix+0x54>
days += y & 0x03 ? 365 : 366;
months = year & 0x03 ? regyear : leapyear;
ffc2349c: 3d 60 00 00 lis r11,0
ffc234a0: 39 6b 22 ac addi r11,r11,8876
ffc234a4: 41 82 00 64 beq- ffc23508 <msdos_date_dos2unix+0xdc> <== ALWAYS TAKEN
/*
* Prevent going from 0 to 0xffffffff in the following
* loop.
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
ffc234a8: 54 6a df 3f rlwinm. r10,r3,27,28,31 <== NOT EXECUTED
ffc234ac: 41 82 00 20 beq- ffc234cc <msdos_date_dos2unix+0xa0> <== NOT EXECUTED
month = 1;
}
for (m = 0; m < month - 1; m++)
ffc234b0: 35 4a ff ff addic. r10,r10,-1
ffc234b4: 41 82 00 18 beq- ffc234cc <msdos_date_dos2unix+0xa0> <== ALWAYS TAKEN
ffc234b8: 7d 49 03 a6 mtctr r10 <== NOT EXECUTED
* Convert from dos' idea of time to unix'. This will probably only be
* called from the stat(), and fstat() system calls and so probably need
* not be too efficient.
*/
unsigned int
msdos_date_dos2unix(unsigned int dd, unsigned int dt)
ffc234bc: 39 6b ff fe addi r11,r11,-2 <== NOT EXECUTED
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
month = 1;
}
for (m = 0; m < month - 1; m++)
days += months[m];
ffc234c0: a5 4b 00 02 lhzu r10,2(r11) <== NOT EXECUTED
ffc234c4: 7c 00 52 14 add r0,r0,r10 <== NOT EXECUTED
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
month = 1;
}
for (m = 0; m < month - 1; m++)
ffc234c8: 42 00 ff f8 bdnz+ ffc234c0 <msdos_date_dos2unix+0x94> <== NOT EXECUTED
days += months[m];
days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;
ffc234cc: 54 63 06 fe clrlwi r3,r3,27
ffc234d0: 38 63 ff ff addi r3,r3,-1
ffc234d4: 7c 03 02 14 add r0,r3,r0
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
ffc234d8: 54 0b 38 30 rlwinm r11,r0,7,0,24
ffc234dc: 54 00 48 2c rlwinm r0,r0,9,0,22
ffc234e0: 7c 0b 00 50 subf r0,r11,r0
ffc234e4: 54 0b 20 36 rlwinm r11,r0,4,0,27
ffc234e8: 7c 00 58 50 subf r0,r0,r11
ffc234ec: 54 0b 20 36 rlwinm r11,r0,4,0,27
ffc234f0: 7d 60 58 50 subf r11,r0,r11
ffc234f4: 3d 6b 12 cf addis r11,r11,4815
ffc234f8: 38 0b a6 00 addi r0,r11,-23040
ffc234fc: 90 09 00 10 stw r0,16(r9)
}
return seconds + lastseconds;
}
ffc23500: 7c 60 22 14 add r3,r0,r4
ffc23504: 4e 80 00 20 blr
/*
* Prevent going from 0 to 0xffffffff in the following
* loop.
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
ffc23508: 54 6a df 3f rlwinm. r10,r3,27,28,31
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
days += y & 0x03 ? 365 : 366;
months = year & 0x03 ? regyear : leapyear;
ffc2350c: 39 6b 00 18 addi r11,r11,24
/*
* Prevent going from 0 to 0xffffffff in the following
* loop.
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
ffc23510: 41 a2 ff bc beq- ffc234cc <msdos_date_dos2unix+0xa0> <== NEVER TAKEN
ffc23514: 4b ff ff 9c b ffc234b0 <msdos_date_dos2unix+0x84>
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
ffc23518: 80 09 00 10 lwz r0,16(r9)
days += months[m];
days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
}
return seconds + lastseconds;
}
ffc2351c: 7c 60 22 14 add r3,r0,r4
ffc23520: 4e 80 00 20 blr
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
days += y & 0x03 ? 365 : 366;
months = year & 0x03 ? regyear : leapyear;
ffc23524: 3d 60 00 00 lis r11,0 <== NOT EXECUTED
ffc23528: 39 6b 22 ac addi r11,r11,8876 <== NOT EXECUTED
ffc2352c: 39 6b 00 18 addi r11,r11,24 <== NOT EXECUTED
ffc23530: 4b ff ff 78 b ffc234a8 <msdos_date_dos2unix+0x7c> <== NOT EXECUTED
ffc232b4 <msdos_date_unix2dos>:
/*
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
ffc232b4: 3d 20 00 00 lis r9,0
ffc232b8: 80 09 2a fc lwz r0,11004(r9)
ffc232bc: 38 e9 2a fc addi r7,r9,11004
ffc232c0: 7f 80 18 00 cmpw cr7,r0,r3
ffc232c4: 41 9e 01 44 beq- cr7,ffc23408 <msdos_date_unix2dos+0x154>
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
ffc232c8: 3c 00 88 88 lis r0,-30584
/*
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
ffc232cc: 90 69 2a fc stw r3,11004(r9)
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
ffc232d0: 3d 60 91 a2 lis r11,-28254
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
ffc232d4: 60 00 88 89 ori r0,r0,34953
* If the number of days since 1970 is the same as the last
* time we did the computation then skip all this leap year
* and month stuff.
*/
days = t / (SECONDSPERDAY);
if (days != lastday) {
ffc232d8: 81 07 00 08 lwz r8,8(r7)
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
ffc232dc: 61 6b b3 c5 ori r11,r11,46021
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
ffc232e0: 7d 43 00 16 mulhwu r10,r3,r0
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
ffc232e4: 7d 63 58 16 mulhwu r11,r3,r11
ffc232e8: 3d 80 aa aa lis r12,-21846
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
ffc232ec: 55 49 d9 7e rlwinm r9,r10,27,5,31
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
ffc232f0: 55 6b aa fe rlwinm r11,r11,21,11,31
ffc232f4: 61 8c aa ab ori r12,r12,43691
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
ffc232f8: 7c c9 00 16 mulhwu r6,r9,r0
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
ffc232fc: 7d 8b 60 16 mulhwu r12,r11,r12
/*
* If the number of days since 1970 is the same as the last
* time we did the computation then skip all this leap year
* and month stuff.
*/
days = t / (SECONDSPERDAY);
ffc23300: 3c 00 c2 2e lis r0,-15826
ffc23304: 60 00 45 07 ori r0,r0,17671
ffc23308: 7c 03 00 16 mulhwu r0,r3,r0
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
ffc2330c: 54 c6 d9 7e rlwinm r6,r6,27,5,31
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
ffc23310: 55 8c e1 3e rlwinm r12,r12,28,4,31
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
ffc23314: 1c c6 00 3c mulli r6,r6,60
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
ffc23318: 1d 8c 00 18 mulli r12,r12,24
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
ffc2331c: 1d 49 00 3c mulli r10,r9,60
/*
* If the number of days since 1970 is the same as the last
* time we did the computation then skip all this leap year
* and month stuff.
*/
days = t / (SECONDSPERDAY);
ffc23320: 54 00 84 3e rlwinm r0,r0,16,16,31
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
ffc23324: 7c c6 48 50 subf r6,r6,r9
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
ffc23328: 7d 6c 58 50 subf r11,r12,r11
* If the number of days since 1970 is the same as the last
* time we did the computation then skip all this leap year
* and month stuff.
*/
days = t / (SECONDSPERDAY);
if (days != lastday) {
ffc2332c: 7f 80 40 00 cmpw cr7,r0,r8
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
ffc23330: 54 c6 28 34 rlwinm r6,r6,5,0,26
ffc23334: 55 6b 58 28 rlwinm r11,r11,11,0,20
ffc23338: 7c 6a 18 50 subf r3,r10,r3
ffc2333c: 7c c6 5a 14 add r6,r6,r11
ffc23340: 54 63 f8 7e rlwinm r3,r3,31,1,31
ffc23344: 7c c6 1a 14 add r6,r6,r3
ffc23348: 54 c6 04 3e clrlwi r6,r6,16
ffc2334c: b0 c7 00 04 sth r6,4(r7)
* If the number of days since 1970 is the same as the last
* time we did the computation then skip all this leap year
* and month stuff.
*/
days = t / (SECONDSPERDAY);
if (days != lastday) {
ffc23350: 41 9e 00 cc beq- cr7,ffc2341c <msdos_date_unix2dos+0x168><== NEVER TAKEN
lastday = days;
ffc23354: 90 07 00 08 stw r0,8(r7)
for (year = 1970;; year++) {
ffc23358: 39 20 07 b2 li r9,1970
ffc2335c: 48 00 00 0c b ffc23368 <msdos_date_unix2dos+0xb4>
inc = year & 0x03 ? 365 : 366;
if (days < inc)
break;
days -= inc;
ffc23360: 7c 0b 00 50 subf r0,r11,r0
* and month stuff.
*/
days = t / (SECONDSPERDAY);
if (days != lastday) {
lastday = days;
for (year = 1970;; year++) {
ffc23364: 39 29 00 01 addi r9,r9,1
inc = year & 0x03 ? 365 : 366;
ffc23368: 71 2b 00 03 andi. r11,r9,3
ffc2336c: 7d 60 00 26 mfcr r11
ffc23370: 55 6b 1f fe rlwinm r11,r11,3,31,31
ffc23374: 39 6b 01 6d addi r11,r11,365
if (days < inc)
ffc23378: 7f 80 58 40 cmplw cr7,r0,r11
ffc2337c: 40 9c ff e4 bge+ cr7,ffc23360 <msdos_date_unix2dos+0xac>
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
ffc23380: 3d 40 00 00 lis r10,0
ffc23384: 39 4a 22 ac addi r10,r10,8876
ffc23388: 41 82 00 68 beq- ffc233f0 <msdos_date_unix2dos+0x13c> <== ALWAYS TAKEN
for (month = 0; month < 12; month++) {
ffc2338c: 39 60 00 0c li r11,12
ffc23390: 7d 69 03 a6 mtctr r11
/*
* Convert the unix version of time to dos's idea of time to be used in
* file timestamps. The passed in unix time is assumed to be in GMT.
*/
void
msdos_date_unix2dos(unsigned int t, uint16_t *ddp,
ffc23394: 39 4a ff fe addi r10,r10,-2
if (days < inc)
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
for (month = 0; month < 12; month++) {
ffc23398: 39 00 00 00 li r8,0
if (days < months[month])
ffc2339c: a5 6a 00 02 lhzu r11,2(r10)
ffc233a0: 7f 8b 00 40 cmplw cr7,r11,r0
ffc233a4: 41 9d 00 54 bgt- cr7,ffc233f8 <msdos_date_unix2dos+0x144><== ALWAYS TAKEN
break;
days -= months[month];
ffc233a8: 7c 0b 00 50 subf r0,r11,r0 <== NOT EXECUTED
if (days < inc)
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
for (month = 0; month < 12; month++) {
ffc233ac: 39 08 00 01 addi r8,r8,1 <== NOT EXECUTED
ffc233b0: 42 00 ff ec bdnz+ ffc2339c <msdos_date_unix2dos+0xe8> <== NOT EXECUTED
ffc233b4: 39 60 01 a0 li r11,416 <== NOT EXECUTED
* Remember dos's idea of time is relative to 1980.
* unix's is relative to 1970. If somehow we get a
* time before 1980 then don't give totally crazy
* results.
*/
if (year > 1980)
ffc233b8: 2b 89 07 bc cmplwi cr7,r9,1980
for (month = 0; month < 12; month++) {
if (days < months[month])
break;
days -= months[month];
}
lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
ffc233bc: 39 6b 00 01 addi r11,r11,1
ffc233c0: 7c 0b 02 14 add r0,r11,r0
ffc233c4: 54 00 04 3e clrlwi r0,r0,16
ffc233c8: b0 07 00 06 sth r0,6(r7)
* Remember dos's idea of time is relative to 1980.
* unix's is relative to 1970. If somehow we get a
* time before 1980 then don't give totally crazy
* results.
*/
if (year > 1980)
ffc233cc: 40 9d 00 18 ble- cr7,ffc233e4 <msdos_date_unix2dos+0x130><== NEVER TAKEN
lastddate += (year - 1980) <<
ffc233d0: 39 29 f8 44 addi r9,r9,-1980
ffc233d4: 55 29 48 2c rlwinm r9,r9,9,0,22
ffc233d8: 7c 00 4a 14 add r0,r0,r9
ffc233dc: 54 00 04 3e clrlwi r0,r0,16
ffc233e0: b0 07 00 06 sth r0,6(r7)
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
ffc233e4: b0 c5 00 00 sth r6,0(r5)
*ddp = lastddate;
ffc233e8: b0 04 00 00 sth r0,0(r4)
}
ffc233ec: 4e 80 00 20 blr
inc = year & 0x03 ? 365 : 366;
if (days < inc)
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
ffc233f0: 39 4a 00 18 addi r10,r10,24
ffc233f4: 4b ff ff 98 b ffc2338c <msdos_date_unix2dos+0xd8>
for (month = 0; month < 12; month++) {
if (days < months[month])
ffc233f8: 55 0b 04 3e clrlwi r11,r8,16
ffc233fc: 39 6b 00 01 addi r11,r11,1
ffc23400: 55 6b 2c 34 rlwinm r11,r11,5,16,26
ffc23404: 4b ff ff b4 b ffc233b8 <msdos_date_unix2dos+0x104>
/*
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
ffc23408: a0 c7 00 04 lhz r6,4(r7)
ffc2340c: a0 07 00 06 lhz r0,6(r7)
if (year > 1980)
lastddate += (year - 1980) <<
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
ffc23410: b0 c5 00 00 sth r6,0(r5)
*ddp = lastddate;
ffc23414: b0 04 00 00 sth r0,0(r4)
}
ffc23418: 4e 80 00 20 blr
* If the number of days since 1970 is the same as the last
* time we did the computation then skip all this leap year
* and month stuff.
*/
days = t / (SECONDSPERDAY);
if (days != lastday) {
ffc2341c: a0 07 00 06 lhz r0,6(r7) <== NOT EXECUTED
if (year > 1980)
lastddate += (year - 1980) <<
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
ffc23420: b0 c5 00 00 sth r6,0(r5) <== NOT EXECUTED
*ddp = lastddate;
ffc23424: b0 04 00 00 sth r0,0(r4) <== NOT EXECUTED
}
ffc23428: 4e 80 00 20 blr <== NOT EXECUTED
ffc23fc8 <msdos_dir_chmod>:
int
msdos_dir_chmod(rtems_filesystem_location_info_t *pathloc,
mode_t mode)
{
return RC_OK;
}
ffc23fc8: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc23fcc: 4e 80 00 20 blr <== NOT EXECUTED
ffc237ac <msdos_dir_close>:
* RC_OK, if directory closed successfully, or -1 if error occured (errno
* set apropriately.
*/
int
msdos_dir_close(rtems_libio_t *iop)
{
ffc237ac: 94 21 ff e8 stwu r1,-24(r1)
ffc237b0: 7c 08 02 a6 mflr r0
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc237b4: 38 80 00 00 li r4,0
* RC_OK, if directory closed successfully, or -1 if error occured (errno
* set apropriately.
*/
int
msdos_dir_close(rtems_libio_t *iop)
{
ffc237b8: 90 01 00 1c stw r0,28(r1)
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc237bc: 38 a0 00 00 li r5,0
int
msdos_dir_close(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
ffc237c0: 81 23 00 2c lwz r9,44(r3)
* RC_OK, if directory closed successfully, or -1 if error occured (errno
* set apropriately.
*/
int
msdos_dir_close(rtems_libio_t *iop)
{
ffc237c4: 93 c1 00 10 stw r30,16(r1)
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
ffc237c8: 83 c9 00 34 lwz r30,52(r9)
* RC_OK, if directory closed successfully, or -1 if error occured (errno
* set apropriately.
*/
int
msdos_dir_close(rtems_libio_t *iop)
{
ffc237cc: 93 e1 00 14 stw r31,20(r1)
ffc237d0: 7c 7f 1b 78 mr r31,r3
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc237d4: 80 7e 00 98 lwz r3,152(r30)
* RC_OK, if directory closed successfully, or -1 if error occured (errno
* set apropriately.
*/
int
msdos_dir_close(rtems_libio_t *iop)
{
ffc237d8: 93 a1 00 0c stw r29,12(r1)
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
ffc237dc: 83 bf 00 1c lwz r29,28(r31)
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc237e0: 4b fe 9f ad bl ffc0d78c <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc237e4: 2f 83 00 00 cmpwi cr7,r3,0
ffc237e8: 40 9e 00 3c bne- cr7,ffc23824 <msdos_dir_close+0x78> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EIO );
rc = fat_file_close(iop->pathinfo.mt_entry, fat_fd);
ffc237ec: 80 7f 00 2c lwz r3,44(r31)
ffc237f0: 7f a4 eb 78 mr r4,r29
ffc237f4: 4b ff 40 8d bl ffc17880 <fat_file_close>
if (rc != RC_OK)
ffc237f8: 7c 7f 1b 79 mr. r31,r3
{
rtems_semaphore_release(fs_info->vol_sema);
ffc237fc: 80 7e 00 98 lwz r3,152(r30)
return rc;
}
rtems_semaphore_release(fs_info->vol_sema);
ffc23800: 4b fe a1 19 bl ffc0d918 <rtems_semaphore_release>
return RC_OK;
}
ffc23804: 80 01 00 1c lwz r0,28(r1)
ffc23808: 7f e3 fb 78 mr r3,r31
ffc2380c: 83 a1 00 0c lwz r29,12(r1)
ffc23810: 7c 08 03 a6 mtlr r0
ffc23814: 83 c1 00 10 lwz r30,16(r1)
ffc23818: 83 e1 00 14 lwz r31,20(r1)
ffc2381c: 38 21 00 18 addi r1,r1,24
ffc23820: 4e 80 00 20 blr
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one( EIO );
ffc23824: 48 00 09 ed bl ffc24210 <__errno> <== NOT EXECUTED
ffc23828: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc2382c: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc23830: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc23834: 4b ff ff d0 b ffc23804 <msdos_dir_close+0x58> <== NOT EXECUTED
ffc20214 <msdos_dir_is_empty>:
msdos_dir_is_empty(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
ffc20214: 94 21 ff c8 stwu r1,-56(r1) <== NOT EXECUTED
ffc20218: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc2021c: 90 01 00 3c stw r0,60(r1) <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t j = 0, i = 0;
/* dir is not empty */
*ret_val = false;
ffc20220: 38 00 00 00 li r0,0 <== NOT EXECUTED
msdos_dir_is_empty(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
ffc20224: 93 e1 00 34 stw r31,52(r1) <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
ffc20228: 83 e3 00 34 lwz r31,52(r3) <== NOT EXECUTED
msdos_dir_is_empty(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
ffc2022c: 92 81 00 08 stw r20,8(r1) <== NOT EXECUTED
ffc20230: 93 01 00 18 stw r24,24(r1) <== NOT EXECUTED
ffc20234: 93 21 00 1c stw r25,28(r1) <== NOT EXECUTED
ffc20238: 7c 99 23 78 mr r25,r4 <== NOT EXECUTED
ffc2023c: 93 41 00 20 stw r26,32(r1) <== NOT EXECUTED
ffc20240: 7c ba 2b 78 mr r26,r5 <== NOT EXECUTED
ffc20244: 93 61 00 24 stw r27,36(r1) <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
MSDOS_SHORT_NAME_LEN) == 0) ||
(strncmp(MSDOS_DIR_NAME((entry)),
ffc20248: 3f 60 ff c3 lis r27,-61 <== NOT EXECUTED
ffc2024c: 3b 7b 55 e8 addi r27,r27,21992 <== NOT EXECUTED
msdos_dir_is_empty(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
ffc20250: 93 81 00 28 stw r28,40(r1) <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t j = 0, i = 0;
ffc20254: 3b 80 00 00 li r28,0 <== NOT EXECUTED
msdos_dir_is_empty(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
ffc20258: 93 a1 00 2c stw r29,44(r1) <== NOT EXECUTED
ffc2025c: 7c 7d 1b 78 mr r29,r3 <== NOT EXECUTED
ffc20260: 93 c1 00 30 stw r30,48(r1) <== NOT EXECUTED
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
ffc20264: 3f c0 ff c3 lis r30,-61 <== NOT EXECUTED
ffc20268: 3b de 55 dc addi r30,r30,21980 <== NOT EXECUTED
msdos_dir_is_empty(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
ffc2026c: 92 a1 00 0c stw r21,12(r1) <== NOT EXECUTED
ffc20270: 92 c1 00 10 stw r22,16(r1) <== NOT EXECUTED
ffc20274: 92 e1 00 14 stw r23,20(r1) <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t j = 0, i = 0;
/* dir is not empty */
*ret_val = false;
ffc20278: a2 9f 00 00 lhz r20,0(r31) <== NOT EXECUTED
ffc2027c: 98 05 00 00 stb r0,0(r5) <== NOT EXECUTED
ffc20280: 83 1f 00 9c lwz r24,156(r31) <== NOT EXECUTED
while ((ret = fat_file_read(mt_entry, fat_fd, j * fs_info->fat.vol.bps,
ffc20284: 7c b4 e1 d6 mullw r5,r20,r28 <== NOT EXECUTED
ffc20288: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc2028c: 7f 24 cb 78 mr r4,r25 <== NOT EXECUTED
ffc20290: 7e 86 a3 78 mr r6,r20 <== NOT EXECUTED
ffc20294: 7f 07 c3 78 mr r7,r24 <== NOT EXECUTED
ffc20298: 4b ff 72 21 bl ffc174b8 <fat_file_read> <== NOT EXECUTED
ffc2029c: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc202a0: 41 82 00 ec beq- ffc2038c <msdos_dir_is_empty+0x178> <== NOT EXECUTED
fs_info->fat.vol.bps,
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
ffc202a4: 2f 83 00 1f cmpwi cr7,r3,31 <== NOT EXECUTED
ffc202a8: 40 9d 00 f4 ble- cr7,ffc2039c <msdos_dir_is_empty+0x188><== NOT EXECUTED
return -1;
assert(ret == fs_info->fat.vol.bps);
ffc202ac: a2 9f 00 00 lhz r20,0(r31) <== NOT EXECUTED
ffc202b0: 7f 94 18 00 cmpw cr7,r20,r3 <== NOT EXECUTED
ffc202b4: 40 9e 00 f0 bne- cr7,ffc203a4 <msdos_dir_is_empty+0x190><== NOT EXECUTED
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
ffc202b8: 41 82 00 c8 beq- ffc20380 <msdos_dir_is_empty+0x16c> <== NOT EXECUTED
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
return -1;
assert(ret == fs_info->fat.vol.bps);
ffc202bc: 83 1f 00 9c lwz r24,156(r31) <== NOT EXECUTED
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
ffc202c0: 3a c0 00 00 li r22,0 <== NOT EXECUTED
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
return -1;
assert(ret == fs_info->fat.vol.bps);
ffc202c4: 7f 17 c3 78 mr r23,r24 <== NOT EXECUTED
* then consider it as empty.
*
* Just ignore long file name entries. They must have a short entry to
* be valid.
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
ffc202c8: 8a b7 00 00 lbz r21,0(r23) <== NOT EXECUTED
ffc202cc: 2f 95 00 e5 cmpwi cr7,r21,229 <== NOT EXECUTED
ffc202d0: 41 9e 00 98 beq- cr7,ffc20368 <msdos_dir_is_empty+0x154><== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
ffc202d4: 88 17 00 0b lbz r0,11(r23) <== NOT EXECUTED
ffc202d8: 54 00 06 be clrlwi r0,r0,26 <== NOT EXECUTED
*
* Just ignore long file name entries. They must have a short entry to
* be valid.
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
ffc202dc: 2f 80 00 0f cmpwi cr7,r0,15 <== NOT EXECUTED
ffc202e0: 41 9e 00 88 beq- cr7,ffc20368 <msdos_dir_is_empty+0x154><== NOT EXECUTED
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
ffc202e4: 7e e3 bb 78 mr r3,r23 <== NOT EXECUTED
ffc202e8: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc202ec: 38 a0 00 0b li r5,11 <== NOT EXECUTED
ffc202f0: 48 00 5b 59 bl ffc25e48 <strncmp> <== NOT EXECUTED
* be valid.
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
ffc202f4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc202f8: 41 9e 00 70 beq- cr7,ffc20368 <msdos_dir_is_empty+0x154><== NOT EXECUTED
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
MSDOS_SHORT_NAME_LEN) == 0) ||
(strncmp(MSDOS_DIR_NAME((entry)),
ffc202fc: 7e e3 bb 78 mr r3,r23 <== NOT EXECUTED
ffc20300: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc20304: 38 a0 00 0b li r5,11 <== NOT EXECUTED
ffc20308: 48 00 5b 41 bl ffc25e48 <strncmp> <== NOT EXECUTED
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
MSDOS_SHORT_NAME_LEN) == 0) ||
ffc2030c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc20310: 41 9e 00 58 beq- cr7,ffc20368 <msdos_dir_is_empty+0x154><== NOT EXECUTED
continue;
/*
* Nothing more to look at.
*/
if ((*MSDOS_DIR_NAME(entry)) ==
ffc20314: 2f 95 00 00 cmpwi cr7,r21,0 <== NOT EXECUTED
}
/*
* Short file name entries mean not empty.
*/
return RC_OK;
ffc20318: 38 60 00 00 li r3,0 <== NOT EXECUTED
continue;
/*
* Nothing more to look at.
*/
if ((*MSDOS_DIR_NAME(entry)) ==
ffc2031c: 40 9e 00 0c bne- cr7,ffc20328 <msdos_dir_is_empty+0x114><== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
{
*ret_val = true;
ffc20320: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc20324: 98 1a 00 00 stb r0,0(r26) <== NOT EXECUTED
}
j++;
}
*ret_val = true;
return RC_OK;
}
ffc20328: 80 01 00 3c lwz r0,60(r1) <== NOT EXECUTED
ffc2032c: 82 81 00 08 lwz r20,8(r1) <== NOT EXECUTED
ffc20330: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc20334: 82 a1 00 0c lwz r21,12(r1) <== NOT EXECUTED
ffc20338: 82 c1 00 10 lwz r22,16(r1) <== NOT EXECUTED
ffc2033c: 82 e1 00 14 lwz r23,20(r1) <== NOT EXECUTED
ffc20340: 83 01 00 18 lwz r24,24(r1) <== NOT EXECUTED
ffc20344: 83 21 00 1c lwz r25,28(r1) <== NOT EXECUTED
ffc20348: 83 41 00 20 lwz r26,32(r1) <== NOT EXECUTED
ffc2034c: 83 61 00 24 lwz r27,36(r1) <== NOT EXECUTED
ffc20350: 83 81 00 28 lwz r28,40(r1) <== NOT EXECUTED
ffc20354: 83 a1 00 2c lwz r29,44(r1) <== NOT EXECUTED
ffc20358: 83 c1 00 30 lwz r30,48(r1) <== NOT EXECUTED
ffc2035c: 83 e1 00 34 lwz r31,52(r1) <== NOT EXECUTED
ffc20360: 38 21 00 38 addi r1,r1,56 <== NOT EXECUTED
ffc20364: 4e 80 00 20 blr <== NOT EXECUTED
assert(ret == fs_info->fat.vol.bps);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
i < fs_info->fat.vol.bps;
i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
ffc20368: 3a d6 00 20 addi r22,r22,32 <== NOT EXECUTED
return -1;
assert(ret == fs_info->fat.vol.bps);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
ffc2036c: 7f 96 a0 40 cmplw cr7,r22,r20 <== NOT EXECUTED
i < fs_info->fat.vol.bps;
i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
ffc20370: 3a f7 00 20 addi r23,r23,32 <== NOT EXECUTED
return -1;
assert(ret == fs_info->fat.vol.bps);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
ffc20374: 41 9c ff 54 blt+ cr7,ffc202c8 <msdos_dir_is_empty+0xb4> <== NOT EXECUTED
/*
* Short file name entries mean not empty.
*/
return RC_OK;
}
j++;
ffc20378: 3b 9c 00 01 addi r28,r28,1 <== NOT EXECUTED
ffc2037c: 4b ff ff 08 b ffc20284 <msdos_dir_is_empty+0x70> <== NOT EXECUTED
*/
if ((*MSDOS_DIR_NAME(entry)) ==
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
{
*ret_val = true;
return RC_OK;
ffc20380: 83 1f 00 9c lwz r24,156(r31) <== NOT EXECUTED
/*
* Short file name entries mean not empty.
*/
return RC_OK;
}
j++;
ffc20384: 3b 9c 00 01 addi r28,r28,1 <== NOT EXECUTED
ffc20388: 4b ff fe fc b ffc20284 <msdos_dir_is_empty+0x70> <== NOT EXECUTED
}
*ret_val = true;
ffc2038c: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc20390: 98 1a 00 00 stb r0,0(r26) <== NOT EXECUTED
return RC_OK;
ffc20394: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc20398: 4b ff ff 90 b ffc20328 <msdos_dir_is_empty+0x114> <== NOT EXECUTED
while ((ret = fat_file_read(mt_entry, fat_fd, j * fs_info->fat.vol.bps,
fs_info->fat.vol.bps,
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
return -1;
ffc2039c: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc203a0: 4b ff ff 88 b ffc20328 <msdos_dir_is_empty+0x114> <== NOT EXECUTED
assert(ret == fs_info->fat.vol.bps);
ffc203a4: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc203a8: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
ffc203ac: 3c c0 ff c3 lis r6,-61 <== NOT EXECUTED
ffc203b0: 38 63 55 74 addi r3,r3,21876 <== NOT EXECUTED
ffc203b4: 38 80 03 b5 li r4,949 <== NOT EXECUTED
ffc203b8: 38 a5 54 fc addi r5,r5,21756 <== NOT EXECUTED
ffc203bc: 38 c6 55 c0 addi r6,r6,21952 <== NOT EXECUTED
ffc203c0: 4b fe 78 d1 bl ffc07c90 <__assert_func> <== NOT EXECUTED
ffc23e28 <msdos_dir_lseek>:
* set apropriately).
*/
rtems_off64_t
msdos_dir_lseek(rtems_libio_t *iop, rtems_off64_t offset, int whence)
{
switch (whence)
ffc23e28: 2b 87 00 01 cmplwi cr7,r7,1 <== NOT EXECUTED
* RC_OK on success, or -1 if error occured (errno
* set apropriately).
*/
rtems_off64_t
msdos_dir_lseek(rtems_libio_t *iop, rtems_off64_t offset, int whence)
{
ffc23e2c: 94 21 ff f8 stwu r1,-8(r1) <== NOT EXECUTED
ffc23e30: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
case SEEK_END:
default:
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return RC_OK;
ffc23e34: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc23e38: 38 80 00 00 li r4,0 <== NOT EXECUTED
* RC_OK on success, or -1 if error occured (errno
* set apropriately).
*/
rtems_off64_t
msdos_dir_lseek(rtems_libio_t *iop, rtems_off64_t offset, int whence)
{
ffc23e3c: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
switch (whence)
ffc23e40: 40 9d 00 18 ble- cr7,ffc23e58 <msdos_dir_lseek+0x30> <== NOT EXECUTED
* Movement past the end of the directory via lseek is not a
* permitted operation
*/
case SEEK_END:
default:
rtems_set_errno_and_return_minus_one( EINVAL );
ffc23e44: 48 00 03 cd bl ffc24210 <__errno> <== NOT EXECUTED
ffc23e48: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc23e4c: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc23e50: 38 80 ff ff li r4,-1 <== NOT EXECUTED
ffc23e54: 38 60 ff ff li r3,-1 <== NOT EXECUTED
break;
}
return RC_OK;
}
ffc23e58: 80 01 00 0c lwz r0,12(r1) <== NOT EXECUTED
ffc23e5c: 38 21 00 08 addi r1,r1,8 <== NOT EXECUTED
ffc23e60: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc23e64: 4e 80 00 20 blr <== NOT EXECUTED
ffc23710 <msdos_dir_open>:
* set apropriately)
*/
int
msdos_dir_open(rtems_libio_t *iop, const char *pathname, uint32_t flag,
uint32_t mode)
{
ffc23710: 94 21 ff e8 stwu r1,-24(r1)
ffc23714: 7c 08 02 a6 mflr r0
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc23718: 38 80 00 00 li r4,0
* set apropriately)
*/
int
msdos_dir_open(rtems_libio_t *iop, const char *pathname, uint32_t flag,
uint32_t mode)
{
ffc2371c: 90 01 00 1c stw r0,28(r1)
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc23720: 38 a0 00 00 li r5,0
msdos_dir_open(rtems_libio_t *iop, const char *pathname, uint32_t flag,
uint32_t mode)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
ffc23724: 81 23 00 2c lwz r9,44(r3)
* set apropriately)
*/
int
msdos_dir_open(rtems_libio_t *iop, const char *pathname, uint32_t flag,
uint32_t mode)
{
ffc23728: 93 c1 00 10 stw r30,16(r1)
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
ffc2372c: 83 c9 00 34 lwz r30,52(r9)
* set apropriately)
*/
int
msdos_dir_open(rtems_libio_t *iop, const char *pathname, uint32_t flag,
uint32_t mode)
{
ffc23730: 93 e1 00 14 stw r31,20(r1)
ffc23734: 7c 7f 1b 78 mr r31,r3
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc23738: 80 7e 00 98 lwz r3,152(r30)
* set apropriately)
*/
int
msdos_dir_open(rtems_libio_t *iop, const char *pathname, uint32_t flag,
uint32_t mode)
{
ffc2373c: 93 a1 00 0c stw r29,12(r1)
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
ffc23740: 83 bf 00 1c lwz r29,28(r31)
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc23744: 4b fe a0 49 bl ffc0d78c <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc23748: 2f 83 00 00 cmpwi cr7,r3,0
ffc2374c: 40 9e 00 4c bne- cr7,ffc23798 <msdos_dir_open+0x88> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EIO );
rc = fat_file_reopen(fat_fd);
ffc23750: 7f a3 eb 78 mr r3,r29
ffc23754: 4b ff 3d 4d bl ffc174a0 <fat_file_reopen>
if (rc != RC_OK)
ffc23758: 7c 7d 1b 79 mr. r29,r3
ffc2375c: 40 82 00 14 bne- ffc23770 <msdos_dir_open+0x60> <== NEVER TAKEN
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
iop->offset = 0;
ffc23760: 39 40 00 00 li r10,0
ffc23764: 39 60 00 00 li r11,0
ffc23768: 91 5f 00 10 stw r10,16(r31)
ffc2376c: 91 7f 00 14 stw r11,20(r31)
rtems_semaphore_release(fs_info->vol_sema);
ffc23770: 80 7e 00 98 lwz r3,152(r30)
ffc23774: 4b fe a1 a5 bl ffc0d918 <rtems_semaphore_release>
return RC_OK;
}
ffc23778: 80 01 00 1c lwz r0,28(r1)
ffc2377c: 7f a3 eb 78 mr r3,r29
ffc23780: 83 c1 00 10 lwz r30,16(r1)
ffc23784: 7c 08 03 a6 mtlr r0
ffc23788: 83 a1 00 0c lwz r29,12(r1)
ffc2378c: 83 e1 00 14 lwz r31,20(r1)
ffc23790: 38 21 00 18 addi r1,r1,24
ffc23794: 4e 80 00 20 blr
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one( EIO );
ffc23798: 48 00 0a 79 bl ffc24210 <__errno> <== NOT EXECUTED
ffc2379c: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc237a0: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc237a4: 3b a0 ff ff li r29,-1 <== NOT EXECUTED
ffc237a8: 4b ff ff d0 b ffc23778 <msdos_dir_open+0x68> <== NOT EXECUTED
ffc23838 <msdos_dir_read>:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
{
ffc23838: 94 21 fe 70 stwu r1,-400(r1) <== NOT EXECUTED
ffc2383c: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc23840: 7d 80 00 26 mfcr r12 <== NOT EXECUTED
ffc23844: 90 01 01 94 stw r0,404(r1) <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
fat_file_fd_t *tmp_fat_fd = NULL;
ffc23848: 38 00 00 00 li r0,0 <== NOT EXECUTED
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
{
ffc2384c: 92 81 01 60 stw r20,352(r1) <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
ffc23850: 82 83 00 1c lwz r20,28(r3) <== NOT EXECUTED
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
ffc23854: 81 23 00 2c lwz r9,44(r3) <== NOT EXECUTED
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
ffc23858: 81 74 00 20 lwz r11,32(r20) <== NOT EXECUTED
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
{
ffc2385c: 92 41 01 58 stw r18,344(r1) <== NOT EXECUTED
ffc23860: 7c 92 23 78 mr r18,r4 <== NOT EXECUTED
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
ffc23864: 2f 8b 00 01 cmpwi cr7,r11,1 <== NOT EXECUTED
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
{
ffc23868: 93 61 01 7c stw r27,380(r1) <== NOT EXECUTED
ffc2386c: 7c 7b 1b 78 mr r27,r3 <== NOT EXECUTED
ffc23870: 93 81 01 80 stw r28,384(r1) <== NOT EXECUTED
ffc23874: 93 a1 01 84 stw r29,388(r1) <== NOT EXECUTED
ffc23878: 93 c1 01 88 stw r30,392(r1) <== NOT EXECUTED
ffc2387c: 93 e1 01 8c stw r31,396(r1) <== NOT EXECUTED
ffc23880: 7c bf 2b 78 mr r31,r5 <== NOT EXECUTED
ffc23884: 91 c1 01 48 stw r14,328(r1) <== NOT EXECUTED
ffc23888: 91 e1 01 4c stw r15,332(r1) <== NOT EXECUTED
ffc2388c: 92 01 01 50 stw r16,336(r1) <== NOT EXECUTED
ffc23890: 92 21 01 54 stw r17,340(r1) <== NOT EXECUTED
ffc23894: 92 61 01 5c stw r19,348(r1) <== NOT EXECUTED
ffc23898: 92 a1 01 64 stw r21,356(r1) <== NOT EXECUTED
ffc2389c: 92 c1 01 68 stw r22,360(r1) <== NOT EXECUTED
ffc238a0: 92 e1 01 6c stw r23,364(r1) <== NOT EXECUTED
ffc238a4: 93 01 01 70 stw r24,368(r1) <== NOT EXECUTED
ffc238a8: 93 21 01 74 stw r25,372(r1) <== NOT EXECUTED
ffc238ac: 93 41 01 78 stw r26,376(r1) <== NOT EXECUTED
ffc238b0: 91 81 01 44 stw r12,324(r1) <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
ffc238b4: 83 c9 00 34 lwz r30,52(r9) <== NOT EXECUTED
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
fat_file_fd_t *tmp_fat_fd = NULL;
ffc238b8: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
uint32_t start = 0;
ssize_t ret = 0;
uint32_t cmpltd = 0;
uint32_t j = 0, i = 0;
uint32_t bts2rd = 0;
uint32_t cur_cln = 0;
ffc238bc: 90 01 00 08 stw r0,8(r1) <== NOT EXECUTED
/*
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
ffc238c0: 83 83 00 10 lwz r28,16(r3) <== NOT EXECUTED
ffc238c4: 83 a3 00 14 lwz r29,20(r3) <== NOT EXECUTED
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
ffc238c8: 41 9e 04 34 beq- cr7,ffc23cfc <msdos_dir_read+0x4c4> <== NOT EXECUTED
ffc238cc: a2 1e 00 06 lhz r16,6(r30) <== NOT EXECUTED
fs_info->fat.vol.bpc;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc238d0: 80 7e 00 98 lwz r3,152(r30) <== NOT EXECUTED
ffc238d4: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc238d8: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc238dc: 4b fe 9e b1 bl ffc0d78c <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc238e0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc238e4: 40 9e 04 b4 bne- cr7,ffc23d98 <msdos_dir_read+0x560> <== NOT EXECUTED
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
ffc238e8: 3c 00 0e a0 lis r0,3744 <== NOT EXECUTED
ffc238ec: 60 00 ea 0f ori r0,r0,59919 <== NOT EXECUTED
ffc238f0: 57 ff e8 fe rlwinm r31,r31,29,3,31 <== NOT EXECUTED
ffc238f4: 7f 1f 00 16 mulhwu r24,r31,r0 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
while (count > 0)
ffc238f8: 38 00 00 00 li r0,0 <== NOT EXECUTED
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
ffc238fc: 57 18 f8 7e rlwinm r24,r24,31,1,31 <== NOT EXECUTED
ffc23900: 1f 18 01 18 mulli r24,r24,280 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
while (count > 0)
ffc23904: 2e 18 00 00 cmpwi cr4,r24,0 <== NOT EXECUTED
ffc23908: 41 92 00 e8 beq- cr4,ffc239f0 <msdos_dir_read+0x1b8> <== NOT EXECUTED
/*
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
ffc2390c: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc23910: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc23914: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc23918: 38 c0 01 18 li r6,280 <== NOT EXECUTED
ffc2391c: 48 00 e3 89 bl ffc31ca4 <__divdi3> <== NOT EXECUTED
ffc23920: 3a c0 00 00 li r22,0 <== NOT EXECUTED
ffc23924: 7c 9c 23 78 mr r28,r4 <== NOT EXECUTED
ffc23928: 3a e0 00 00 li r23,0 <== NOT EXECUTED
ffc2392c: 3a 20 00 00 li r17,0 <== NOT EXECUTED
ffc23930: 3b 40 ff ff li r26,-1 <== NOT EXECUTED
ffc23934: 3b 20 00 00 li r25,0 <== NOT EXECUTED
*/
if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK)) ||
(lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry)))
{
lfn_start = FAT_FILE_SHORT_NAME;
ffc23938: 3a a0 ff ff li r21,-1 <== NOT EXECUTED
}
/* fill in dirent structure */
/* XXX: from what and in what d_off should be computed ?! */
tmp_dirent.d_off = start + cmpltd;
tmp_dirent.d_reclen = sizeof(struct dirent);
ffc2393c: 3a 60 01 18 li r19,280 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
ffc23940: 39 c0 00 2e li r14,46 <== NOT EXECUTED
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
ffc23944: 3d e0 00 00 lis r15,0 <== NOT EXECUTED
* fat-file is already opened by open call, so read it
* Always read directory fat-file from the beggining because of MSDOS
* directories feature :( - we should count elements currently
* present in the directory because there may be holes :)
*/
ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, (j * bts2rd),
ffc23948: 80 7b 00 2c lwz r3,44(r27) <== NOT EXECUTED
ffc2394c: 7e 84 a3 78 mr r4,r20 <== NOT EXECUTED
ffc23950: 80 fe 00 9c lwz r7,156(r30) <== NOT EXECUTED
ffc23954: 7e c5 b3 78 mr r5,r22 <== NOT EXECUTED
ffc23958: 7e 06 83 78 mr r6,r16 <== NOT EXECUTED
ffc2395c: 4b ff 3b 5d bl ffc174b8 <fat_file_read> <== NOT EXECUTED
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
ffc23960: 2f 83 00 1f cmpwi cr7,r3,31 <== NOT EXECUTED
* fat-file is already opened by open call, so read it
* Always read directory fat-file from the beggining because of MSDOS
* directories feature :( - we should count elements currently
* present in the directory because there may be holes :)
*/
ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, (j * bts2rd),
ffc23964: 7c 7d 1b 78 mr r29,r3 <== NOT EXECUTED
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
ffc23968: 40 9d 04 28 ble- cr7,ffc23d90 <msdos_dir_read+0x558> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
ffc2396c: 81 3e 00 9c lwz r9,156(r30) <== NOT EXECUTED
/*
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
ffc23970: 88 09 00 00 lbz r0,0(r9) <== NOT EXECUTED
ffc23974: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc23978: 41 9e 03 14 beq- cr7,ffc23c8c <msdos_dir_read+0x454> <== NOT EXECUTED
ffc2397c: 3b e0 00 00 li r31,0 <== NOT EXECUTED
ffc23980: 48 00 00 28 b ffc239a8 <msdos_dir_read+0x170> <== NOT EXECUTED
/* Is the directory entry empty */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) == MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* Is the directory entry empty a volume label */
if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&
ffc23984: 41 9e 00 80 beq- cr7,ffc23a04 <msdos_dir_read+0x1cc> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
rtems_set_errno_and_return_minus_one(EIO);
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
ffc23988: 3b ff 00 20 addi r31,r31,32 <== NOT EXECUTED
ffc2398c: 7f 9f e8 40 cmplw cr7,r31,r29 <== NOT EXECUTED
ffc23990: 40 9c 00 54 bge- cr7,ffc239e4 <msdos_dir_read+0x1ac> <== NOT EXECUTED
{
char* entry = (char*) fs_info->cl_buf + i;
ffc23994: 81 3e 00 9c lwz r9,156(r30) <== NOT EXECUTED
/*
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
ffc23998: 7c 09 f8 ae lbzx r0,r9,r31 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
ffc2399c: 7d 29 fa 14 add r9,r9,r31 <== NOT EXECUTED
/*
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
ffc239a0: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc239a4: 41 9e 02 e8 beq- cr7,ffc23c8c <msdos_dir_read+0x454> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return cmpltd;
}
/* Is the directory entry empty */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) == MSDOS_THIS_DIR_ENTRY_EMPTY)
ffc239a8: 2f 80 00 e5 cmpwi cr7,r0,229 <== NOT EXECUTED
ffc239ac: 41 be ff dc beq- cr7,ffc23988 <msdos_dir_read+0x150> <== NOT EXECUTED
continue;
/* Is the directory entry empty a volume label */
if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&
ffc239b0: 89 69 00 0b lbz r11,11(r9) <== NOT EXECUTED
ffc239b4: 71 6a 00 08 andi. r10,r11,8 <== NOT EXECUTED
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) != MSDOS_ATTR_LFN))
ffc239b8: 55 6b 06 be clrlwi r11,r11,26 <== NOT EXECUTED
/* Is the directory entry empty */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) == MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* Is the directory entry empty a volume label */
if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&
ffc239bc: 2f 8b 00 0f cmpwi cr7,r11,15 <== NOT EXECUTED
ffc239c0: 40 a2 ff c4 bne- ffc23984 <msdos_dir_read+0x14c> <== NOT EXECUTED
/*
* Check the attribute to see if the entry is for a long file
* name.
*/
if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
ffc239c4: 41 9e 00 40 beq- cr7,ffc23a04 <msdos_dir_read+0x1cc> <== NOT EXECUTED
fat_dir_pos_t dir_pos;
/*
* Skip active entries until get the entry to start from.
*/
if (start)
ffc239c8: 2f 9c 00 00 cmpwi cr7,r28,0 <== NOT EXECUTED
ffc239cc: 41 9e 00 d4 beq- cr7,ffc23aa0 <msdos_dir_read+0x268> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
rtems_set_errno_and_return_minus_one(EIO);
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
ffc239d0: 3b ff 00 20 addi r31,r31,32 <== NOT EXECUTED
ffc239d4: 7f 9f e8 40 cmplw cr7,r31,r29 <== NOT EXECUTED
* Skip active entries until get the entry to start from.
*/
if (start)
{
lfn_start = FAT_FILE_SHORT_NAME;
start--;
ffc239d8: 3b 9c ff ff addi r28,r28,-1 <== NOT EXECUTED
/*
* Skip active entries until get the entry to start from.
*/
if (start)
{
lfn_start = FAT_FILE_SHORT_NAME;
ffc239dc: 3b 40 ff ff li r26,-1 <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
rtems_set_errno_and_return_minus_one(EIO);
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
ffc239e0: 41 9c ff b4 blt+ cr7,ffc23994 <msdos_dir_read+0x15c> <== NOT EXECUTED
ffc239e4: 7e d6 82 14 add r22,r22,r16 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
while (count > 0)
ffc239e8: 40 92 ff 60 bne+ cr4,ffc23948 <msdos_dir_read+0x110> <== NOT EXECUTED
ffc239ec: 7f 20 cb 78 mr r0,r25 <== NOT EXECUTED
break;
}
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
ffc239f0: 80 7e 00 98 lwz r3,152(r30) <== NOT EXECUTED
ffc239f4: 90 01 01 38 stw r0,312(r1) <== NOT EXECUTED
ffc239f8: 4b fe 9f 21 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
ffc239fc: 80 01 01 38 lwz r0,312(r1) <== NOT EXECUTED
return cmpltd;
ffc23a00: 48 00 02 98 b ffc23c98 <msdos_dir_read+0x460> <== NOT EXECUTED
int q;
/*
* Is this is the first entry of a LFN ?
*/
if (lfn_start == FAT_FILE_SHORT_NAME)
ffc23a04: 2f 9a ff ff cmpwi cr7,r26,-1 <== NOT EXECUTED
ffc23a08: 41 9e 02 38 beq- cr7,ffc23c40 <msdos_dir_read+0x408> <== NOT EXECUTED
* If the entry number or the check sum do not match
* forget this series of long directory entries. These could
* be orphaned entries depending on the history of the
* disk.
*/
if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
ffc23a0c: 88 09 00 00 lbz r0,0(r9) <== NOT EXECUTED
ffc23a10: 54 00 06 be clrlwi r0,r0,26 <== NOT EXECUTED
ffc23a14: 7f 80 b8 00 cmpw cr7,r0,r23 <== NOT EXECUTED
ffc23a18: 41 9e 00 0c beq- cr7,ffc23a24 <msdos_dir_read+0x1ec> <== NOT EXECUTED
MSDOS_LAST_LONG_ENTRY_MASK)) ||
(lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry)))
{
lfn_start = FAT_FILE_SHORT_NAME;
ffc23a1c: 3b 40 ff ff li r26,-1 <== NOT EXECUTED
ffc23a20: 4b ff ff 68 b ffc23988 <msdos_dir_read+0x150> <== NOT EXECUTED
* be orphaned entries depending on the history of the
* disk.
*/
if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK)) ||
(lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry)))
ffc23a24: 88 c9 00 0d lbz r6,13(r9) <== NOT EXECUTED
* forget this series of long directory entries. These could
* be orphaned entries depending on the history of the
* disk.
*/
if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK)) ||
ffc23a28: 7f 86 88 00 cmpw cr7,r6,r17 <== NOT EXECUTED
ffc23a2c: 40 9e ff f0 bne+ cr7,ffc23a1c <msdos_dir_read+0x1e4> <== NOT EXECUTED
* The DOS maximum length is 255 characters without the
* trailing nul character. We need to range check the length to
* fit in the directory entry name field.
*/
lfn_entries--;
ffc23a30: 3a f7 ff ff addi r23,r23,-1 <== NOT EXECUTED
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
ffc23a34: 1c f7 00 0d mulli r7,r23,13 <== NOT EXECUTED
ffc23a38: 2b 87 00 ff cmplwi cr7,r7,255 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
ffc23a3c: 20 07 01 00 subfic r0,r7,256 <== NOT EXECUTED
* trailing nul character. We need to range check the length to
* fit in the directory entry name field.
*/
lfn_entries--;
p = entry + 1;
ffc23a40: 39 29 00 01 addi r9,r9,1 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
ffc23a44: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
* fit in the directory entry name field.
*/
lfn_entries--;
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
ffc23a48: 7c eb 3b 78 mr r11,r7 <== NOT EXECUTED
ffc23a4c: 39 40 00 01 li r10,1 <== NOT EXECUTED
ffc23a50: 41 9d 03 cc bgt- cr7,ffc23e1c <msdos_dir_read+0x5e4> <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
ffc23a54: 38 01 00 20 addi r0,r1,32 <== NOT EXECUTED
ffc23a58: 7d 00 5a 14 add r8,r0,r11 <== NOT EXECUTED
ffc23a5c: 7c 07 58 50 subf r0,r7,r11 <== NOT EXECUTED
lfn_entries--;
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
ffc23a60: 2c 0a 00 0d cmpwi r10,13 <== NOT EXECUTED
tmp_dirent.d_name[o++] = *p;
if (*p == '\0')
break;
switch (q)
ffc23a64: 2f 80 00 04 cmpwi cr7,r0,4 <== NOT EXECUTED
ffc23a68: 2c 80 00 0a cmpwi cr1,r0,10 <== NOT EXECUTED
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
{
if (o >= (sizeof(tmp_dirent.d_name) - 1))
break;
tmp_dirent.d_name[o++] = *p;
ffc23a6c: 39 6b 00 01 addi r11,r11,1 <== NOT EXECUTED
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
{
if (o >= (sizeof(tmp_dirent.d_name) - 1))
ffc23a70: 42 40 02 c4 bdz- ffc23d34 <msdos_dir_read+0x4fc> <== NOT EXECUTED
break;
tmp_dirent.d_name[o++] = *p;
ffc23a74: 88 09 00 00 lbz r0,0(r9) <== NOT EXECUTED
ffc23a78: 98 08 00 14 stb r0,20(r8) <== NOT EXECUTED
if (*p == '\0')
ffc23a7c: 88 09 00 00 lbz r0,0(r9) <== NOT EXECUTED
ffc23a80: 2f 00 00 00 cmpwi cr6,r0,0 <== NOT EXECUTED
ffc23a84: 41 9a 02 b0 beq- cr6,ffc23d34 <msdos_dir_read+0x4fc> <== NOT EXECUTED
break;
switch (q)
ffc23a88: 41 9e 02 a0 beq- cr7,ffc23d28 <msdos_dir_read+0x4f0> <== NOT EXECUTED
ffc23a8c: 41 86 02 90 beq- cr1,ffc23d1c <msdos_dir_read+0x4e4> <== NOT EXECUTED
lfn_entries--;
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
ffc23a90: 41 82 02 a4 beq- ffc23d34 <msdos_dir_read+0x4fc> <== NOT EXECUTED
break;
case 10:
p += 4;
break;
default:
p += 2;
ffc23a94: 39 29 00 02 addi r9,r9,2 <== NOT EXECUTED
* fit in the directory entry name field.
*/
lfn_entries--;
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
ffc23a98: 39 4a 00 01 addi r10,r10,1 <== NOT EXECUTED
ffc23a9c: 4b ff ff b8 b ffc23a54 <msdos_dir_read+0x21c> <== NOT EXECUTED
* unfortunately there is no method to extract ino except to
* open fat-file descriptor :( ... so, open it
*/
/* get number of cluster we are working with */
rc = fat_file_ioctl(iop->pathinfo.mt_entry, fat_fd, F_CLU_NUM,
ffc23aa0: 80 7b 00 2c lwz r3,44(r27) <== NOT EXECUTED
ffc23aa4: 7e 84 a3 78 mr r4,r20 <== NOT EXECUTED
ffc23aa8: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc23aac: 91 21 01 38 stw r9,312(r1) <== NOT EXECUTED
ffc23ab0: 7e c6 b3 78 mr r6,r22 <== NOT EXECUTED
ffc23ab4: 38 e1 00 08 addi r7,r1,8 <== NOT EXECUTED
ffc23ab8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc23abc: 4b ff 3e c1 bl ffc1797c <fat_file_ioctl> <== NOT EXECUTED
j * bts2rd, &cur_cln);
if (rc != RC_OK)
ffc23ac0: 81 21 01 38 lwz r9,312(r1) <== NOT EXECUTED
ffc23ac4: 7c 60 1b 79 mr. r0,r3 <== NOT EXECUTED
ffc23ac8: 40 a2 ff 28 bne- ffc239f0 <msdos_dir_read+0x1b8> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
fat_dir_pos_init(&dir_pos);
dir_pos.sname.cln = cur_cln;
ffc23acc: 80 01 00 08 lwz r0,8(r1) <== NOT EXECUTED
dir_pos.sname.ofs = i;
rc = fat_file_open(iop->pathinfo.mt_entry, &dir_pos, &tmp_fat_fd);
ffc23ad0: 38 81 00 10 addi r4,r1,16 <== NOT EXECUTED
ffc23ad4: 80 7b 00 2c lwz r3,44(r27) <== NOT EXECUTED
ffc23ad8: 38 a1 00 0c addi r5,r1,12 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
fat_dir_pos_init(&dir_pos);
dir_pos.sname.cln = cur_cln;
ffc23adc: 90 01 00 10 stw r0,16(r1) <== NOT EXECUTED
dir_pos.sname.ofs = i;
rc = fat_file_open(iop->pathinfo.mt_entry, &dir_pos, &tmp_fat_fd);
ffc23ae0: 91 21 01 38 stw r9,312(r1) <== NOT EXECUTED
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
ffc23ae4: 92 a1 00 18 stw r21,24(r1) <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
ffc23ae8: 92 a1 00 1c stw r21,28(r1) <== NOT EXECUTED
return rc;
}
fat_dir_pos_init(&dir_pos);
dir_pos.sname.cln = cur_cln;
dir_pos.sname.ofs = i;
ffc23aec: 93 e1 00 14 stw r31,20(r1) <== NOT EXECUTED
rc = fat_file_open(iop->pathinfo.mt_entry, &dir_pos, &tmp_fat_fd);
ffc23af0: 4b ff 36 ad bl ffc1719c <fat_file_open> <== NOT EXECUTED
if (rc != RC_OK)
ffc23af4: 7c 60 1b 79 mr. r0,r3 <== NOT EXECUTED
ffc23af8: 81 21 01 38 lwz r9,312(r1) <== NOT EXECUTED
ffc23afc: 40 a2 fe f4 bne- ffc239f0 <msdos_dir_read+0x1b8> <== NOT EXECUTED
/*
* If a long file name check if the correct number of
* entries have been found and if the checksum is correct.
* If not return the short file name.
*/
if (lfn_start != FAT_FILE_SHORT_NAME)
ffc23b00: 2f 9a ff ff cmpwi cr7,r26,-1 <== NOT EXECUTED
/* fill in dirent structure */
/* XXX: from what and in what d_off should be computed ?! */
tmp_dirent.d_off = start + cmpltd;
tmp_dirent.d_reclen = sizeof(struct dirent);
tmp_dirent.d_ino = tmp_fat_fd->ino;
ffc23b04: 81 61 00 0c lwz r11,12(r1) <== NOT EXECUTED
return rc;
}
/* fill in dirent structure */
/* XXX: from what and in what d_off should be computed ?! */
tmp_dirent.d_off = start + cmpltd;
ffc23b08: 93 21 00 2c stw r25,44(r1) <== NOT EXECUTED
tmp_dirent.d_reclen = sizeof(struct dirent);
tmp_dirent.d_ino = tmp_fat_fd->ino;
ffc23b0c: 80 0b 00 0c lwz r0,12(r11) <== NOT EXECUTED
return rc;
}
/* fill in dirent structure */
/* XXX: from what and in what d_off should be computed ?! */
tmp_dirent.d_off = start + cmpltd;
ffc23b10: 93 81 00 28 stw r28,40(r1) <== NOT EXECUTED
tmp_dirent.d_reclen = sizeof(struct dirent);
ffc23b14: b2 61 00 30 sth r19,48(r1) <== NOT EXECUTED
tmp_dirent.d_ino = tmp_fat_fd->ino;
ffc23b18: 90 01 00 20 stw r0,32(r1) <== NOT EXECUTED
/*
* If a long file name check if the correct number of
* entries have been found and if the checksum is correct.
* If not return the short file name.
*/
if (lfn_start != FAT_FILE_SHORT_NAME)
ffc23b1c: 41 9e 00 70 beq- cr7,ffc23b8c <msdos_dir_read+0x354> <== NOT EXECUTED
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
ffc23b20: 39 00 00 0b li r8,11 <== NOT EXECUTED
ffc23b24: 7d 09 03 a6 mtctr r8 <== NOT EXECUTED
/*
* If a long file name check if the correct number of
* entries have been found and if the checksum is correct.
* If not return the short file name.
*/
if (lfn_start != FAT_FILE_SHORT_NAME)
ffc23b28: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc23b2c: 39 60 00 00 li r11,0 <== NOT EXECUTED
ffc23b30: 39 40 00 00 li r10,0 <== NOT EXECUTED
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
ffc23b34: 7d 09 58 ae lbzx r8,r9,r11 <== NOT EXECUTED
ffc23b38: 54 00 f8 7e rlwinm r0,r0,31,1,31 <== NOT EXECUTED
ffc23b3c: 7c 0a 02 14 add r0,r10,r0 <== NOT EXECUTED
ffc23b40: 7c 00 42 14 add r0,r0,r8 <== NOT EXECUTED
ffc23b44: 54 00 06 3e clrlwi r0,r0,24 <== NOT EXECUTED
ffc23b48: 70 0a 00 01 andi. r10,r0,1 <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
ffc23b4c: 39 6b 00 01 addi r11,r11,1 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
ffc23b50: 39 40 00 00 li r10,0 <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
ffc23b54: 42 40 00 30 bdz- ffc23b84 <msdos_dir_read+0x34c> <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
ffc23b58: 41 a2 ff dc beq- ffc23b34 <msdos_dir_read+0x2fc> <== NOT EXECUTED
ffc23b5c: 39 40 00 80 li r10,128 <== NOT EXECUTED
ffc23b60: 7d 09 58 ae lbzx r8,r9,r11 <== NOT EXECUTED
ffc23b64: 54 00 f8 7e rlwinm r0,r0,31,1,31 <== NOT EXECUTED
ffc23b68: 7c 0a 02 14 add r0,r10,r0 <== NOT EXECUTED
ffc23b6c: 7c 00 42 14 add r0,r0,r8 <== NOT EXECUTED
ffc23b70: 54 00 06 3e clrlwi r0,r0,24 <== NOT EXECUTED
ffc23b74: 70 0a 00 01 andi. r10,r0,1 <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
ffc23b78: 39 6b 00 01 addi r11,r11,1 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
ffc23b7c: 39 40 00 00 li r10,0 <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
ffc23b80: 42 00 ff d8 bdnz+ ffc23b58 <msdos_dir_read+0x320> <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entries || (lfn_checksum != cs))
ffc23b84: 2f 97 00 00 cmpwi cr7,r23,0 <== NOT EXECUTED
ffc23b88: 41 9e 00 ec beq- cr7,ffc23c74 <msdos_dir_read+0x43c> <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
ffc23b8c: 38 e0 00 08 li r7,8 <== NOT EXECUTED
ffc23b90: 7c e9 03 a6 mtctr r7 <== NOT EXECUTED
src_tmp = src + MSDOS_SHORT_BASE_LEN-1);
ffc23b94: 38 c9 00 07 addi r6,r9,7 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
ffc23b98: 39 69 00 08 addi r11,r9,8 <== NOT EXECUTED
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
src_tmp = src + MSDOS_SHORT_BASE_LEN-1);
((i > 0) &&
ffc23b9c: 8c 0b ff ff lbzu r0,-1(r11) <== NOT EXECUTED
ffc23ba0: 2f 80 00 20 cmpwi cr7,r0,32 <== NOT EXECUTED
ffc23ba4: 40 9e 01 9c bne- cr7,ffc23d40 <msdos_dir_read+0x508> <== NOT EXECUTED
(*src_tmp == ' '));
i--,src_tmp--)
ffc23ba8: 38 e7 ff ff addi r7,r7,-1 <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
ffc23bac: 42 00 ff f0 bdnz+ ffc23b9c <msdos_dir_read+0x364> <== NOT EXECUTED
{
/*
* convert dir entry from fixed 8+3 format (without dot)
* to 0..8 + 1dot + 0..3 format
*/
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
ffc23bb0: 39 41 00 34 addi r10,r1,52 <== NOT EXECUTED
/*
* find last non-blank character of extension
*/
for ((i = MSDOS_SHORT_EXT_LEN ,
src_tmp = src + MSDOS_SHORT_BASE_LEN+MSDOS_SHORT_EXT_LEN-1);
((i > 0) &&
ffc23bb4: 88 09 00 0a lbz r0,10(r9) <== NOT EXECUTED
ffc23bb8: 2f 80 00 20 cmpwi cr7,r0,32 <== NOT EXECUTED
ffc23bbc: 40 9e 02 58 bne- cr7,ffc23e14 <msdos_dir_read+0x5dc> <== NOT EXECUTED
ffc23bc0: 88 09 00 09 lbz r0,9(r9) <== NOT EXECUTED
ffc23bc4: 2f 80 00 20 cmpwi cr7,r0,32 <== NOT EXECUTED
ffc23bc8: 40 9e 01 e4 bne- cr7,ffc23dac <msdos_dir_read+0x574> <== NOT EXECUTED
ffc23bcc: 88 09 00 08 lbz r0,8(r9) <== NOT EXECUTED
ffc23bd0: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc23bd4: 2f 80 00 20 cmpwi cr7,r0,32 <== NOT EXECUTED
ffc23bd8: 40 9e 01 d8 bne- cr7,ffc23db0 <msdos_dir_read+0x578> <== NOT EXECUTED
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
len++;
}
}
*dst = '\0'; /* terminate string */
ffc23bdc: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc23be0: 98 0a 00 00 stb r0,0(r10) <== NOT EXECUTED
{
/*
* convert dir entry from fixed 8+3 format (without dot)
* to 0..8 + 1dot + 0..3 format
*/
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
ffc23be4: 3b 40 ff ff li r26,-1 <== NOT EXECUTED
ffc23be8: b0 e1 00 32 sth r7,50(r1) <== NOT EXECUTED
else
{
tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
ffc23bec: 38 81 00 20 addi r4,r1,32 <== NOT EXECUTED
ffc23bf0: 38 a0 01 18 li r5,280 <== NOT EXECUTED
ffc23bf4: 7c 72 ca 14 add r3,r18,r25 <== NOT EXECUTED
ffc23bf8: 48 00 14 4d bl ffc25044 <memcpy> <== NOT EXECUTED
iop->offset = iop->offset + sizeof(struct dirent);
ffc23bfc: 81 5b 00 10 lwz r10,16(r27) <== NOT EXECUTED
ffc23c00: 81 7b 00 14 lwz r11,20(r27) <== NOT EXECUTED
cmpltd += (sizeof(struct dirent));
count -= (sizeof(struct dirent));
/* inode number extracted, close fat-file */
rc = fat_file_close(iop->pathinfo.mt_entry, tmp_fat_fd);
ffc23c04: 80 7b 00 2c lwz r3,44(r27) <== NOT EXECUTED
tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
iop->offset = iop->offset + sizeof(struct dirent);
ffc23c08: 31 6b 01 18 addic r11,r11,280 <== NOT EXECUTED
ffc23c0c: 7d 4a 01 94 addze r10,r10 <== NOT EXECUTED
cmpltd += (sizeof(struct dirent));
count -= (sizeof(struct dirent));
/* inode number extracted, close fat-file */
rc = fat_file_close(iop->pathinfo.mt_entry, tmp_fat_fd);
ffc23c10: 80 81 00 0c lwz r4,12(r1) <== NOT EXECUTED
tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
iop->offset = iop->offset + sizeof(struct dirent);
ffc23c14: 91 5b 00 10 stw r10,16(r27) <== NOT EXECUTED
ffc23c18: 91 7b 00 14 stw r11,20(r27) <== NOT EXECUTED
cmpltd += (sizeof(struct dirent));
count -= (sizeof(struct dirent));
/* inode number extracted, close fat-file */
rc = fat_file_close(iop->pathinfo.mt_entry, tmp_fat_fd);
ffc23c1c: 4b ff 3c 65 bl ffc17880 <fat_file_close> <== NOT EXECUTED
if (rc != RC_OK)
ffc23c20: 7c 60 1b 79 mr. r0,r3 <== NOT EXECUTED
ffc23c24: 40 a2 fd cc bne- ffc239f0 <msdos_dir_read+0x1b8> <== NOT EXECUTED
ffc23c28: 3b 18 fe e8 addi r24,r24,-280 <== NOT EXECUTED
ffc23c2c: 2e 18 00 00 cmpwi cr4,r24,0 <== NOT EXECUTED
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
iop->offset = iop->offset + sizeof(struct dirent);
cmpltd += (sizeof(struct dirent));
ffc23c30: 3b 39 01 18 addi r25,r25,280 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
if (count <= 0)
ffc23c34: 40 92 fd 54 bne+ cr4,ffc23988 <msdos_dir_read+0x150> <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
while (count > 0)
ffc23c38: 7f 20 cb 78 mr r0,r25 <== NOT EXECUTED
ffc23c3c: 4b ff fd b4 b ffc239f0 <msdos_dir_read+0x1b8> <== NOT EXECUTED
if (lfn_start == FAT_FILE_SHORT_NAME)
{
/*
* The first entry must have the last long entry flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
ffc23c40: 70 0b 00 40 andi. r11,r0,64 <== NOT EXECUTED
ffc23c44: 41 82 fd 44 beq+ ffc23988 <msdos_dir_read+0x150> <== NOT EXECUTED
/*
* Remember the start location of the long file name.
*/
lfn_start =
((j * bts2rd) + i) / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
ffc23c48: 7f 56 fa 14 add r26,r22,r31 <== NOT EXECUTED
* Get the number of entries so we can count down and
* also the checksum of the short entry.
*/
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK);
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
ffc23c4c: 8a 29 00 0d lbz r17,13(r9) <== NOT EXECUTED
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
ffc23c50: 38 61 00 34 addi r3,r1,52 <== NOT EXECUTED
ffc23c54: 91 21 01 38 stw r9,312(r1) <== NOT EXECUTED
ffc23c58: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc23c5c: 38 a0 01 00 li r5,256 <== NOT EXECUTED
/*
* Get the number of entries so we can count down and
* also the checksum of the short entry.
*/
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
ffc23c60: 54 17 06 be clrlwi r23,r0,26 <== NOT EXECUTED
MSDOS_LAST_LONG_ENTRY_MASK);
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
ffc23c64: 48 00 14 c5 bl ffc25128 <memset> <== NOT EXECUTED
continue;
/*
* Remember the start location of the long file name.
*/
lfn_start =
ffc23c68: 57 5a d9 7e rlwinm r26,r26,27,5,31 <== NOT EXECUTED
* also the checksum of the short entry.
*/
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK);
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
ffc23c6c: 81 21 01 38 lwz r9,312(r1) <== NOT EXECUTED
ffc23c70: 4b ff fd 9c b ffc23a0c <msdos_dir_read+0x1d4> <== NOT EXECUTED
int i;
for (i = 0; i < 11; i++, p++)
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entries || (lfn_checksum != cs))
ffc23c74: 7f 80 88 00 cmpw cr7,r0,r17 <== NOT EXECUTED
ffc23c78: 40 9e ff 14 bne+ cr7,ffc23b8c <msdos_dir_read+0x354> <== NOT EXECUTED
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
tmp_dirent.d_name, entry); /* src text */
}
else
{
tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);
ffc23c7c: 38 61 00 34 addi r3,r1,52 <== NOT EXECUTED
ffc23c80: 48 00 21 0d bl ffc25d8c <strlen> <== NOT EXECUTED
ffc23c84: b0 61 00 32 sth r3,50(r1) <== NOT EXECUTED
ffc23c88: 4b ff ff 64 b ffc23bec <msdos_dir_read+0x3b4> <== NOT EXECUTED
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
{
rtems_semaphore_release(fs_info->vol_sema);
ffc23c8c: 80 7e 00 98 lwz r3,152(r30) <== NOT EXECUTED
ffc23c90: 4b fe 9c 89 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
return cmpltd;
ffc23c94: 7f 20 cb 78 mr r0,r25 <== NOT EXECUTED
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
return cmpltd;
}
ffc23c98: 7c 03 03 78 mr r3,r0 <== NOT EXECUTED
ffc23c9c: 80 01 01 94 lwz r0,404(r1) <== NOT EXECUTED
ffc23ca0: 81 81 01 44 lwz r12,324(r1) <== NOT EXECUTED
ffc23ca4: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc23ca8: 81 c1 01 48 lwz r14,328(r1) <== NOT EXECUTED
ffc23cac: 81 e1 01 4c lwz r15,332(r1) <== NOT EXECUTED
ffc23cb0: 7d 80 81 20 mtcrf 8,r12 <== NOT EXECUTED
ffc23cb4: 82 01 01 50 lwz r16,336(r1) <== NOT EXECUTED
ffc23cb8: 82 21 01 54 lwz r17,340(r1) <== NOT EXECUTED
ffc23cbc: 82 41 01 58 lwz r18,344(r1) <== NOT EXECUTED
ffc23cc0: 82 61 01 5c lwz r19,348(r1) <== NOT EXECUTED
ffc23cc4: 82 81 01 60 lwz r20,352(r1) <== NOT EXECUTED
ffc23cc8: 82 a1 01 64 lwz r21,356(r1) <== NOT EXECUTED
ffc23ccc: 82 c1 01 68 lwz r22,360(r1) <== NOT EXECUTED
ffc23cd0: 82 e1 01 6c lwz r23,364(r1) <== NOT EXECUTED
ffc23cd4: 83 01 01 70 lwz r24,368(r1) <== NOT EXECUTED
ffc23cd8: 83 21 01 74 lwz r25,372(r1) <== NOT EXECUTED
ffc23cdc: 83 41 01 78 lwz r26,376(r1) <== NOT EXECUTED
ffc23ce0: 83 61 01 7c lwz r27,380(r1) <== NOT EXECUTED
ffc23ce4: 83 81 01 80 lwz r28,384(r1) <== NOT EXECUTED
ffc23ce8: 83 a1 01 84 lwz r29,388(r1) <== NOT EXECUTED
ffc23cec: 83 c1 01 88 lwz r30,392(r1) <== NOT EXECUTED
ffc23cf0: 83 e1 01 8c lwz r31,396(r1) <== NOT EXECUTED
ffc23cf4: 38 21 01 90 addi r1,r1,400 <== NOT EXECUTED
ffc23cf8: 4e 80 00 20 blr <== NOT EXECUTED
* optimization: we know that root directory for FAT12/16 volumes is
* sequential set of sectors and any cluster is sequential set of sectors
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
ffc23cfc: 80 14 00 24 lwz r0,36(r20) <== NOT EXECUTED
ffc23d00: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc23d04: 40 be fb c8 bne- cr7,ffc238cc <msdos_dir_read+0x94> <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
ffc23d08: 88 1e 00 0a lbz r0,10(r30) <== NOT EXECUTED
* optimization: we know that root directory for FAT12/16 volumes is
* sequential set of sectors and any cluster is sequential set of sectors
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
ffc23d0c: 70 08 00 03 andi. r8,r0,3 <== NOT EXECUTED
ffc23d10: 41 a2 fb bc beq- ffc238cc <msdos_dir_read+0x94> <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
ffc23d14: 82 14 00 18 lwz r16,24(r20) <== NOT EXECUTED
ffc23d18: 4b ff fb b8 b ffc238d0 <msdos_dir_read+0x98> <== NOT EXECUTED
{
case 4:
p += 5;
break;
case 10:
p += 4;
ffc23d1c: 39 29 00 04 addi r9,r9,4 <== NOT EXECUTED
* fit in the directory entry name field.
*/
lfn_entries--;
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
ffc23d20: 39 4a 00 01 addi r10,r10,1 <== NOT EXECUTED
ffc23d24: 4b ff fd 30 b ffc23a54 <msdos_dir_read+0x21c> <== NOT EXECUTED
break;
switch (q)
{
case 4:
p += 5;
ffc23d28: 39 29 00 05 addi r9,r9,5 <== NOT EXECUTED
* fit in the directory entry name field.
*/
lfn_entries--;
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
ffc23d2c: 39 4a 00 01 addi r10,r10,1 <== NOT EXECUTED
ffc23d30: 4b ff fd 24 b ffc23a54 <msdos_dir_read+0x21c> <== NOT EXECUTED
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
ffc23d34: 7c d1 33 78 mr r17,r6 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
if (count <= 0)
ffc23d38: 40 92 fc 50 bne+ cr4,ffc23988 <msdos_dir_read+0x150> <== NOT EXECUTED
ffc23d3c: 4b ff fe fc b ffc23c38 <msdos_dir_read+0x400> <== NOT EXECUTED
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
src_tmp = src + MSDOS_SHORT_BASE_LEN-1);
((i > 0) &&
ffc23d40: 80 af 27 ec lwz r5,10220(r15) <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
ffc23d44: 39 49 ff ff addi r10,r9,-1 <== NOT EXECUTED
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
src_tmp = src + MSDOS_SHORT_BASE_LEN-1);
((i > 0) &&
ffc23d48: 39 61 00 33 addi r11,r1,51 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
ffc23d4c: 7c e9 03 a6 mtctr r7 <== NOT EXECUTED
ffc23d50: 48 00 00 0c b ffc23d5c <msdos_dir_read+0x524> <== NOT EXECUTED
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
ffc23d54: 9c 0b 00 01 stbu r0,1(r11) <== NOT EXECUTED
/*
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
ffc23d58: 42 40 00 28 bdz- ffc23d80 <msdos_dir_read+0x548> <== NOT EXECUTED
*dst++ = tolower((unsigned char)(*src_tmp++));
ffc23d5c: 8c 0a 00 01 lbzu r0,1(r10) <== NOT EXECUTED
ffc23d60: 7d 05 02 14 add r8,r5,r0 <== NOT EXECUTED
ffc23d64: 89 08 00 01 lbz r8,1(r8) <== NOT EXECUTED
ffc23d68: 55 08 07 be clrlwi r8,r8,30 <== NOT EXECUTED
ffc23d6c: 2f 88 00 01 cmpwi cr7,r8,1 <== NOT EXECUTED
ffc23d70: 40 9e ff e4 bne+ cr7,ffc23d54 <msdos_dir_read+0x51c> <== NOT EXECUTED
ffc23d74: 30 00 00 20 addic r0,r0,32 <== NOT EXECUTED
ffc23d78: 9c 0b 00 01 stbu r0,1(r11) <== NOT EXECUTED
/*
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
ffc23d7c: 42 00 ff e0 bdnz+ ffc23d5c <msdos_dir_read+0x524> <== NOT EXECUTED
ffc23d80: 39 61 00 20 addi r11,r1,32 <== NOT EXECUTED
ffc23d84: 7d 4b 3a 14 add r10,r11,r7 <== NOT EXECUTED
ffc23d88: 39 4a 00 14 addi r10,r10,20 <== NOT EXECUTED
ffc23d8c: 4b ff fe 28 b ffc23bb4 <msdos_dir_read+0x37c> <== NOT EXECUTED
*/
ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, (j * bts2rd),
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
rtems_semaphore_release(fs_info->vol_sema);
ffc23d90: 80 7e 00 98 lwz r3,152(r30) <== NOT EXECUTED
ffc23d94: 4b fe 9b 85 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
ffc23d98: 48 00 04 79 bl ffc24210 <__errno> <== NOT EXECUTED
ffc23d9c: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc23da0: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc23da4: 38 00 ff ff li r0,-1 <== NOT EXECUTED
ffc23da8: 4b ff fe f0 b ffc23c98 <msdos_dir_read+0x460> <== NOT EXECUTED
*/
for ((i = MSDOS_SHORT_EXT_LEN ,
src_tmp = src + MSDOS_SHORT_BASE_LEN+MSDOS_SHORT_EXT_LEN-1);
((i > 0) &&
(*src_tmp == ' '));
i--,src_tmp--)
ffc23dac: 38 a0 00 02 li r5,2 <== NOT EXECUTED
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
ffc23db0: 38 05 00 01 addi r0,r5,1 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
ffc23db4: 99 ca 00 00 stb r14,0(r10) <== NOT EXECUTED
ffc23db8: 38 6a 00 01 addi r3,r10,1 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
ffc23dbc: 7c a9 03 a6 mtctr r5 <== NOT EXECUTED
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
ffc23dc0: 7c e7 02 14 add r7,r7,r0 <== NOT EXECUTED
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
ffc23dc4: 81 0f 27 ec lwz r8,10220(r15) <== NOT EXECUTED
ffc23dc8: 38 85 ff ff addi r4,r5,-1 <== NOT EXECUTED
ffc23dcc: 7c cb 33 78 mr r11,r6 <== NOT EXECUTED
ffc23dd0: 7d 49 53 78 mr r9,r10 <== NOT EXECUTED
ffc23dd4: 48 00 00 0c b ffc23de0 <msdos_dir_read+0x5a8> <== NOT EXECUTED
*dst++ = tolower((unsigned char)(*src_tmp++));
ffc23dd8: 9c 09 00 01 stbu r0,1(r9) <== NOT EXECUTED
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
ffc23ddc: 42 40 00 28 bdz- ffc23e04 <msdos_dir_read+0x5cc> <== NOT EXECUTED
*dst++ = tolower((unsigned char)(*src_tmp++));
ffc23de0: 8c 0b 00 01 lbzu r0,1(r11) <== NOT EXECUTED
ffc23de4: 7d 48 02 14 add r10,r8,r0 <== NOT EXECUTED
ffc23de8: 89 4a 00 01 lbz r10,1(r10) <== NOT EXECUTED
ffc23dec: 55 4a 07 be clrlwi r10,r10,30 <== NOT EXECUTED
ffc23df0: 2f 8a 00 01 cmpwi cr7,r10,1 <== NOT EXECUTED
ffc23df4: 40 9e ff e4 bne+ cr7,ffc23dd8 <msdos_dir_read+0x5a0> <== NOT EXECUTED
ffc23df8: 30 00 00 20 addic r0,r0,32 <== NOT EXECUTED
ffc23dfc: 9c 09 00 01 stbu r0,1(r9) <== NOT EXECUTED
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
ffc23e00: 42 00 ff e0 bdnz+ ffc23de0 <msdos_dir_read+0x5a8> <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
ffc23e04: 38 e7 00 01 addi r7,r7,1 <== NOT EXECUTED
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
ffc23e08: 7d 43 2a 14 add r10,r3,r5 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
ffc23e0c: 7c e7 22 14 add r7,r7,r4 <== NOT EXECUTED
ffc23e10: 4b ff fd cc b ffc23bdc <msdos_dir_read+0x3a4> <== NOT EXECUTED
*dst++ = tolower((unsigned char)(*src_tmp++));
}
/*
* find last non-blank character of extension
*/
for ((i = MSDOS_SHORT_EXT_LEN ,
ffc23e14: 38 a0 00 03 li r5,3 <== NOT EXECUTED
ffc23e18: 4b ff ff 98 b ffc23db0 <msdos_dir_read+0x578> <== NOT EXECUTED
ffc23e1c: 39 00 00 01 li r8,1 <== NOT EXECUTED
ffc23e20: 7d 09 03 a6 mtctr r8 <== NOT EXECUTED
ffc23e24: 4b ff fc 30 b ffc23a54 <msdos_dir_read+0x21c> <== NOT EXECUTED
ffc23fd0 <msdos_dir_rmnod>:
* RC_OK on success, or -1 if error occured (errno set apropriately).
*/
int
msdos_dir_rmnod(rtems_filesystem_location_info_t *parent_pathloc,
rtems_filesystem_location_info_t *pathloc)
{
ffc23fd0: 94 21 ff d8 stwu r1,-40(r1) <== NOT EXECUTED
ffc23fd4: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = pathloc->node_access;
bool is_empty = false;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc23fd8: 38 a0 00 00 li r5,0 <== NOT EXECUTED
* RC_OK on success, or -1 if error occured (errno set apropriately).
*/
int
msdos_dir_rmnod(rtems_filesystem_location_info_t *parent_pathloc,
rtems_filesystem_location_info_t *pathloc)
{
ffc23fdc: 90 01 00 2c stw r0,44(r1) <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = pathloc->node_access;
bool is_empty = false;
ffc23fe0: 38 00 00 00 li r0,0 <== NOT EXECUTED
msdos_dir_rmnod(rtems_filesystem_location_info_t *parent_pathloc,
rtems_filesystem_location_info_t *pathloc)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
ffc23fe4: 81 24 00 10 lwz r9,16(r4) <== NOT EXECUTED
* RC_OK on success, or -1 if error occured (errno set apropriately).
*/
int
msdos_dir_rmnod(rtems_filesystem_location_info_t *parent_pathloc,
rtems_filesystem_location_info_t *pathloc)
{
ffc23fe8: 93 a1 00 1c stw r29,28(r1) <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
ffc23fec: 83 a9 00 34 lwz r29,52(r9) <== NOT EXECUTED
* RC_OK on success, or -1 if error occured (errno set apropriately).
*/
int
msdos_dir_rmnod(rtems_filesystem_location_info_t *parent_pathloc,
rtems_filesystem_location_info_t *pathloc)
{
ffc23ff0: 93 e1 00 24 stw r31,36(r1) <== NOT EXECUTED
ffc23ff4: 7c 9f 23 78 mr r31,r4 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = pathloc->node_access;
bool is_empty = false;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc23ff8: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc23ffc: 80 7d 00 98 lwz r3,152(r29) <== NOT EXECUTED
* RC_OK on success, or -1 if error occured (errno set apropriately).
*/
int
msdos_dir_rmnod(rtems_filesystem_location_info_t *parent_pathloc,
rtems_filesystem_location_info_t *pathloc)
{
ffc24000: 93 c1 00 20 stw r30,32(r1) <== NOT EXECUTED
ffc24004: 93 81 00 18 stw r28,24(r1) <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = pathloc->node_access;
ffc24008: 83 df 00 00 lwz r30,0(r31) <== NOT EXECUTED
bool is_empty = false;
ffc2400c: 98 01 00 08 stb r0,8(r1) <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc24010: 4b fe 97 7d bl ffc0d78c <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc24014: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc24018: 40 9e 00 d0 bne- cr7,ffc240e8 <msdos_dir_rmnod+0x118> <== NOT EXECUTED
/*
* We deny attempts to delete open directory (if directory is current
* directory we assume it is open one)
*/
if (fat_fd->links_num > 1)
ffc2401c: 80 1e 00 08 lwz r0,8(r30) <== NOT EXECUTED
ffc24020: 2b 80 00 01 cmplwi cr7,r0,1 <== NOT EXECUTED
ffc24024: 41 9d 00 88 bgt- cr7,ffc240ac <msdos_dir_rmnod+0xdc> <== NOT EXECUTED
}
/*
* You cannot remove a node that still has children
*/
rc = msdos_dir_is_empty(pathloc->mt_entry, fat_fd, &is_empty);
ffc24028: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc2402c: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc24030: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
ffc24034: 4b ff c1 e1 bl ffc20214 <msdos_dir_is_empty> <== NOT EXECUTED
if (rc != RC_OK)
ffc24038: 7c 7c 1b 79 mr. r28,r3 <== NOT EXECUTED
ffc2403c: 40 82 00 44 bne- ffc24080 <msdos_dir_rmnod+0xb0> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
if (!is_empty)
ffc24040: 88 01 00 08 lbz r0,8(r1) <== NOT EXECUTED
ffc24044: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc24048: 41 9e 00 b4 beq- cr7,ffc240fc <msdos_dir_rmnod+0x12c> <== NOT EXECUTED
fat_file_mark_removed(pathloc->mt_entry, fat_fd);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
ffc2404c: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
}
/*
* You cannot remove the file system root node.
*/
if (rtems_filesystem_is_root_location(pathloc))
ffc24050: 81 3f 00 00 lwz r9,0(r31) <== NOT EXECUTED
ffc24054: 80 03 00 1c lwz r0,28(r3) <== NOT EXECUTED
ffc24058: 7f 89 00 00 cmpw cr7,r9,r0 <== NOT EXECUTED
ffc2405c: 41 9e 00 50 beq- cr7,ffc240ac <msdos_dir_rmnod+0xdc> <== NOT EXECUTED
* You cannot remove a mountpoint.
* not used - mount() not implemenetd yet.
*/
/* mark file removed */
rc = msdos_set_first_char4file_name(pathloc->mt_entry, &fat_fd->dir_pos,
ffc24060: 38 9e 00 20 addi r4,r30,32 <== NOT EXECUTED
ffc24064: 38 a0 00 e5 li r5,229 <== NOT EXECUTED
ffc24068: 4b ff bf c1 bl ffc20028 <msdos_set_first_char4file_name><== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
ffc2406c: 7c 7c 1b 79 mr. r28,r3 <== NOT EXECUTED
ffc24070: 40 82 00 10 bne- ffc24080 <msdos_dir_rmnod+0xb0> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
fat_file_mark_removed(pathloc->mt_entry, fat_fd);
ffc24074: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc24078: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc2407c: 4b ff 3e ed bl ffc17f68 <fat_file_mark_removed> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
ffc24080: 80 7d 00 98 lwz r3,152(r29) <== NOT EXECUTED
ffc24084: 4b fe 98 95 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
return rc;
}
ffc24088: 80 01 00 2c lwz r0,44(r1) <== NOT EXECUTED
ffc2408c: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc24090: 83 a1 00 1c lwz r29,28(r1) <== NOT EXECUTED
ffc24094: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc24098: 83 81 00 18 lwz r28,24(r1) <== NOT EXECUTED
ffc2409c: 83 c1 00 20 lwz r30,32(r1) <== NOT EXECUTED
ffc240a0: 83 e1 00 24 lwz r31,36(r1) <== NOT EXECUTED
ffc240a4: 38 21 00 28 addi r1,r1,40 <== NOT EXECUTED
ffc240a8: 4e 80 00 20 blr <== NOT EXECUTED
/*
* You cannot remove the file system root node.
*/
if (rtems_filesystem_is_root_location(pathloc))
{
rtems_semaphore_release(fs_info->vol_sema);
ffc240ac: 80 7d 00 98 lwz r3,152(r29) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EBUSY);
ffc240b0: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
/*
* You cannot remove the file system root node.
*/
if (rtems_filesystem_is_root_location(pathloc))
{
rtems_semaphore_release(fs_info->vol_sema);
ffc240b4: 4b fe 98 65 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EBUSY);
ffc240b8: 48 00 01 59 bl ffc24210 <__errno> <== NOT EXECUTED
ffc240bc: 38 00 00 10 li r0,16 <== NOT EXECUTED
ffc240c0: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
fat_file_mark_removed(pathloc->mt_entry, fat_fd);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
ffc240c4: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc240c8: 80 01 00 2c lwz r0,44(r1) <== NOT EXECUTED
ffc240cc: 83 81 00 18 lwz r28,24(r1) <== NOT EXECUTED
ffc240d0: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc240d4: 83 a1 00 1c lwz r29,28(r1) <== NOT EXECUTED
ffc240d8: 83 c1 00 20 lwz r30,32(r1) <== NOT EXECUTED
ffc240dc: 83 e1 00 24 lwz r31,36(r1) <== NOT EXECUTED
ffc240e0: 38 21 00 28 addi r1,r1,40 <== NOT EXECUTED
ffc240e4: 4e 80 00 20 blr <== NOT EXECUTED
bool is_empty = false;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
ffc240e8: 48 00 01 29 bl ffc24210 <__errno> <== NOT EXECUTED
ffc240ec: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc240f0: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc240f4: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
ffc240f8: 4b ff ff 90 b ffc24088 <msdos_dir_rmnod+0xb8> <== NOT EXECUTED
return rc;
}
if (!is_empty)
{
rtems_semaphore_release(fs_info->vol_sema);
ffc240fc: 80 7d 00 98 lwz r3,152(r29) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOTEMPTY);
ffc24100: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
return rc;
}
if (!is_empty)
{
rtems_semaphore_release(fs_info->vol_sema);
ffc24104: 4b fe 98 15 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOTEMPTY);
ffc24108: 48 00 01 09 bl ffc24210 <__errno> <== NOT EXECUTED
ffc2410c: 38 00 00 5a li r0,90 <== NOT EXECUTED
ffc24110: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc24114: 4b ff ff 74 b ffc24088 <msdos_dir_rmnod+0xb8> <== NOT EXECUTED
ffc23e68 <msdos_dir_stat>:
int
msdos_dir_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
ffc23e68: 94 21 ff e8 stwu r1,-24(r1)
ffc23e6c: 7c 08 02 a6 mflr r0
ffc23e70: 7c 69 1b 78 mr r9,r3
ffc23e74: 90 01 00 1c stw r0,28(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = loc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc23e78: 38 a0 00 00 li r5,0
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
ffc23e7c: 81 63 00 10 lwz r11,16(r3)
int
msdos_dir_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
ffc23e80: 93 c1 00 10 stw r30,16(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
ffc23e84: 83 cb 00 34 lwz r30,52(r11)
int
msdos_dir_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
ffc23e88: 93 e1 00 14 stw r31,20(r1)
ffc23e8c: 7c 9f 23 78 mr r31,r4
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = loc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc23e90: 38 80 00 00 li r4,0
ffc23e94: 80 7e 00 98 lwz r3,152(r30)
int
msdos_dir_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
ffc23e98: 93 a1 00 0c stw r29,12(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = loc->node_access;
ffc23e9c: 83 a9 00 00 lwz r29,0(r9)
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc23ea0: 4b fe 98 ed bl ffc0d78c <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc23ea4: 2c 03 00 00 cmpwi r3,0
ffc23ea8: 40 82 00 80 bne- ffc23f28 <msdos_dir_stat+0xc0> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = fs_info->fat.vol.dev;
ffc23eac: 81 7e 00 5c lwz r11,92(r30)
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
ffc23eb0: 80 1d 00 18 lwz r0,24(r29)
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = fs_info->fat.vol.dev;
ffc23eb4: 81 5e 00 58 lwz r10,88(r30)
buf->st_ino = fat_fd->ino;
ffc23eb8: 80 dd 00 0c lwz r6,12(r29)
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
ffc23ebc: 54 07 ba 7e rlwinm r7,r0,23,9,31
buf->st_blksize = fs_info->fat.vol.bps;
ffc23ec0: a1 1e 00 00 lhz r8,0(r30)
buf->st_mtime = fat_fd->mtime;
ffc23ec4: 81 3d 00 40 lwz r9,64(r29)
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = fs_info->fat.vol.dev;
ffc23ec8: 91 7f 00 04 stw r11,4(r31)
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
ffc23ecc: 39 60 41 ff li r11,16895
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = fs_info->fat.vol.dev;
ffc23ed0: 91 5f 00 00 stw r10,0(r31)
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
ffc23ed4: 39 40 00 00 li r10,0
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = fs_info->fat.vol.dev;
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
ffc23ed8: 91 7f 00 0c stw r11,12(r31)
buf->st_rdev = 0ll;
ffc23edc: 39 60 00 00 li r11,0
buf->st_size = fat_fd->fat_file_size;
ffc23ee0: 90 7f 00 20 stw r3,32(r31)
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = fs_info->fat.vol.dev;
buf->st_ino = fat_fd->ino;
ffc23ee4: 90 df 00 08 stw r6,8(r31)
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
ffc23ee8: 91 5f 00 18 stw r10,24(r31)
ffc23eec: 91 7f 00 1c stw r11,28(r31)
buf->st_size = fat_fd->fat_file_size;
ffc23ef0: 90 1f 00 24 stw r0,36(r31)
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
ffc23ef4: 90 ff 00 44 stw r7,68(r31)
buf->st_blksize = fs_info->fat.vol.bps;
ffc23ef8: 91 1f 00 40 stw r8,64(r31)
buf->st_mtime = fat_fd->mtime;
ffc23efc: 91 3f 00 30 stw r9,48(r31)
rtems_semaphore_release(fs_info->vol_sema);
ffc23f00: 80 7e 00 98 lwz r3,152(r30)
ffc23f04: 4b fe 9a 15 bl ffc0d918 <rtems_semaphore_release>
return RC_OK;
ffc23f08: 38 60 00 00 li r3,0
}
ffc23f0c: 80 01 00 1c lwz r0,28(r1)
ffc23f10: 83 a1 00 0c lwz r29,12(r1)
ffc23f14: 7c 08 03 a6 mtlr r0
ffc23f18: 83 c1 00 10 lwz r30,16(r1)
ffc23f1c: 83 e1 00 14 lwz r31,20(r1)
ffc23f20: 38 21 00 18 addi r1,r1,24
ffc23f24: 4e 80 00 20 blr
fat_file_fd_t *fat_fd = loc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
ffc23f28: 48 00 02 e9 bl ffc24210 <__errno> <== NOT EXECUTED
ffc23f2c: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc23f30: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc23f34: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc23f38: 4b ff ff d4 b ffc23f0c <msdos_dir_stat+0xa4> <== NOT EXECUTED
ffc23f3c <msdos_dir_sync>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set apropriately).
*/
int
msdos_dir_sync(rtems_libio_t *iop)
{
ffc23f3c: 94 21 ff e8 stwu r1,-24(r1) <== NOT EXECUTED
ffc23f40: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc23f44: 38 80 00 00 li r4,0 <== NOT EXECUTED
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set apropriately).
*/
int
msdos_dir_sync(rtems_libio_t *iop)
{
ffc23f48: 90 01 00 1c stw r0,28(r1) <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc23f4c: 38 a0 00 00 li r5,0 <== NOT EXECUTED
msdos_dir_sync(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
ffc23f50: 81 23 00 2c lwz r9,44(r3) <== NOT EXECUTED
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set apropriately).
*/
int
msdos_dir_sync(rtems_libio_t *iop)
{
ffc23f54: 93 c1 00 10 stw r30,16(r1) <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
ffc23f58: 83 c9 00 34 lwz r30,52(r9) <== NOT EXECUTED
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set apropriately).
*/
int
msdos_dir_sync(rtems_libio_t *iop)
{
ffc23f5c: 93 e1 00 14 stw r31,20(r1) <== NOT EXECUTED
ffc23f60: 7c 7f 1b 78 mr r31,r3 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc23f64: 80 7e 00 98 lwz r3,152(r30) <== NOT EXECUTED
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set apropriately).
*/
int
msdos_dir_sync(rtems_libio_t *iop)
{
ffc23f68: 93 a1 00 0c stw r29,12(r1) <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
ffc23f6c: 83 bf 00 1c lwz r29,28(r31) <== NOT EXECUTED
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc23f70: 4b fe 98 1d bl ffc0d78c <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc23f74: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc23f78: 40 9e 00 3c bne- cr7,ffc23fb4 <msdos_dir_sync+0x78> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);
ffc23f7c: 80 7f 00 2c lwz r3,44(r31) <== NOT EXECUTED
ffc23f80: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc23f84: 4b ff 40 ad bl ffc18030 <fat_file_datasync> <== NOT EXECUTED
ffc23f88: 7c 7f 1b 78 mr r31,r3 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
ffc23f8c: 80 7e 00 98 lwz r3,152(r30) <== NOT EXECUTED
ffc23f90: 4b fe 99 89 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
return rc;
}
ffc23f94: 80 01 00 1c lwz r0,28(r1) <== NOT EXECUTED
ffc23f98: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc23f9c: 83 a1 00 0c lwz r29,12(r1) <== NOT EXECUTED
ffc23fa0: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc23fa4: 83 c1 00 10 lwz r30,16(r1) <== NOT EXECUTED
ffc23fa8: 83 e1 00 14 lwz r31,20(r1) <== NOT EXECUTED
ffc23fac: 38 21 00 18 addi r1,r1,24 <== NOT EXECUTED
ffc23fb0: 4e 80 00 20 blr <== NOT EXECUTED
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
ffc23fb4: 48 00 02 5d bl ffc24210 <__errno> <== NOT EXECUTED
ffc23fb8: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc23fbc: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc23fc0: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc23fc4: 4b ff ff d0 b ffc23f94 <msdos_dir_sync+0x58> <== NOT EXECUTED
ffc1ec04 <msdos_eval4make>:
msdos_eval4make(
const char *path,
rtems_filesystem_location_info_t *pathloc,
const char **name
)
{
ffc1ec04: 94 21 ff b0 stwu r1,-80(r1)
ffc1ec08: 7c 08 02 a6 mflr r0
ffc1ec0c: 90 01 00 54 stw r0,84(r1)
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
ffc1ec10: 81 24 00 10 lwz r9,16(r4)
msdos_eval4make(
const char *path,
rtems_filesystem_location_info_t *pathloc,
const char **name
)
{
ffc1ec14: 93 a1 00 44 stw r29,68(r1)
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
ffc1ec18: 83 a9 00 34 lwz r29,52(r9)
msdos_eval4make(
const char *path,
rtems_filesystem_location_info_t *pathloc,
const char **name
)
{
ffc1ec1c: 93 61 00 3c stw r27,60(r1)
ffc1ec20: 7c 7b 1b 78 mr r27,r3
int i = 0;
int token_len;
const char *token;
bool done = false;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1ec24: 80 7d 00 98 lwz r3,152(r29)
msdos_eval4make(
const char *path,
rtems_filesystem_location_info_t *pathloc,
const char **name
)
{
ffc1ec28: 93 41 00 38 stw r26,56(r1)
ffc1ec2c: 7c ba 2b 78 mr r26,r5
int i = 0;
int token_len;
const char *token;
bool done = false;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1ec30: 38 a0 00 00 li r5,0
msdos_eval4make(
const char *path,
rtems_filesystem_location_info_t *pathloc,
const char **name
)
{
ffc1ec34: 93 e1 00 4c stw r31,76(r1)
ffc1ec38: 7c 9f 23 78 mr r31,r4
int i = 0;
int token_len;
const char *token;
bool done = false;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1ec3c: 38 80 00 00 li r4,0
msdos_eval4make(
const char *path,
rtems_filesystem_location_info_t *pathloc,
const char **name
)
{
ffc1ec40: 92 e1 00 2c stw r23,44(r1)
ffc1ec44: 93 01 00 30 stw r24,48(r1)
ffc1ec48: 93 21 00 34 stw r25,52(r1)
ffc1ec4c: 93 81 00 40 stw r28,64(r1)
ffc1ec50: 93 c1 00 48 stw r30,72(r1)
int i = 0;
int token_len;
const char *token;
bool done = false;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1ec54: 4b fe eb 39 bl ffc0d78c <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1ec58: 2f 83 00 00 cmpwi cr7,r3,0
ffc1ec5c: 40 9e 02 88 bne- cr7,ffc1eee4 <msdos_eval4make+0x2e0> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one(EIO);
if (!pathloc->node_access)
ffc1ec60: 80 7f 00 00 lwz r3,0(r31)
ffc1ec64: 2f 83 00 00 cmpwi cr7,r3,0
ffc1ec68: 41 9e 01 a8 beq- cr7,ffc1ee10 <msdos_eval4make+0x20c> <== NEVER TAKEN
goto err;
}
fat_fd = pathloc->node_access;
rc = fat_file_reopen(fat_fd);
ffc1ec6c: 4b ff 88 35 bl ffc174a0 <fat_file_reopen>
if (rc != RC_OK)
ffc1ec70: 7c 7c 1b 79 mr. r28,r3
ffc1ec74: 40 82 00 70 bne- ffc1ece4 <msdos_eval4make+0xe0> <== NEVER TAKEN
ffc1ec78: 3b c0 00 00 li r30,0
/*
* Am I at the root of all filesystems?
* XXX: MSDOS is not supposed to be base fs.
*/
if (pathloc->node_access ==
rtems_filesystem_root.node_access)
ffc1ec7c: 3f 20 00 00 lis r25,0
if (rc != RC_OK)
goto err;
while (!done)
{
type = msdos_get_token(&path[i], strlen(&path[i]), &token, &token_len);
ffc1ec80: 7f 1b f2 14 add r24,r27,r30
ffc1ec84: 7f 03 c3 78 mr r3,r24
ffc1ec88: 48 00 71 05 bl ffc25d8c <strlen>
ffc1ec8c: 38 a1 00 08 addi r5,r1,8
ffc1ec90: 7c 64 1b 78 mr r4,r3
ffc1ec94: 38 c1 00 0c addi r6,r1,12
ffc1ec98: 7f 03 c3 78 mr r3,r24
ffc1ec9c: 48 00 0f 35 bl ffc1fbd0 <msdos_get_token>
i += token_len;
ffc1eca0: 80 a1 00 0c lwz r5,12(r1)
fat_fd = pathloc->node_access;
switch (type)
ffc1eca4: 2f 83 00 02 cmpwi cr7,r3,2
while (!done)
{
type = msdos_get_token(&path[i], strlen(&path[i]), &token, &token_len);
i += token_len;
fat_fd = pathloc->node_access;
ffc1eca8: 82 ff 00 00 lwz r23,0(r31)
if (rc != RC_OK)
goto err;
while (!done)
{
type = msdos_get_token(&path[i], strlen(&path[i]), &token, &token_len);
ffc1ecac: 7c 78 1b 78 mr r24,r3
i += token_len;
ffc1ecb0: 7f de 2a 14 add r30,r30,r5
fat_fd = pathloc->node_access;
switch (type)
ffc1ecb4: 41 9e 01 10 beq- cr7,ffc1edc4 <msdos_eval4make+0x1c0>
ffc1ecb8: 2b 83 00 02 cmplwi cr7,r3,2
ffc1ecbc: 41 9d 00 68 bgt- cr7,ffc1ed24 <msdos_eval4make+0x120>
ffc1ecc0: 2f 83 00 00 cmpwi cr7,r3,0
ffc1ecc4: 40 be ff bc bne- cr7,ffc1ec80 <msdos_eval4make+0x7c>
done = true;
}
break;
case MSDOS_NO_MORE_PATH:
errno = EEXIST;
ffc1ecc8: 48 00 55 49 bl ffc24210 <__errno>
ffc1eccc: 38 00 00 11 li r0,17
ffc1ecd0: 90 03 00 00 stw r0,0(r3)
rc = -1;
ffc1ecd4: 3b 80 ff ff li r28,-1
rtems_semaphore_release(fs_info->vol_sema);
return RC_OK;
error:
fat_file_close(pathloc->mt_entry, fat_fd);
ffc1ecd8: 80 7f 00 10 lwz r3,16(r31)
ffc1ecdc: 7e e4 bb 78 mr r4,r23
ffc1ece0: 4b ff 8b a1 bl ffc17880 <fat_file_close>
err:
rtems_semaphore_release(fs_info->vol_sema);
ffc1ece4: 80 7d 00 98 lwz r3,152(r29)
ffc1ece8: 4b fe ec 31 bl ffc0d918 <rtems_semaphore_release>
return rc;
}
ffc1ecec: 80 01 00 54 lwz r0,84(r1)
ffc1ecf0: 7f 83 e3 78 mr r3,r28
ffc1ecf4: 82 e1 00 2c lwz r23,44(r1)
ffc1ecf8: 7c 08 03 a6 mtlr r0
ffc1ecfc: 83 01 00 30 lwz r24,48(r1)
ffc1ed00: 83 21 00 34 lwz r25,52(r1)
ffc1ed04: 83 41 00 38 lwz r26,56(r1)
ffc1ed08: 83 61 00 3c lwz r27,60(r1)
ffc1ed0c: 83 81 00 40 lwz r28,64(r1)
ffc1ed10: 83 a1 00 44 lwz r29,68(r1)
ffc1ed14: 83 c1 00 48 lwz r30,72(r1)
ffc1ed18: 83 e1 00 4c lwz r31,76(r1)
ffc1ed1c: 38 21 00 50 addi r1,r1,80
ffc1ed20: 4e 80 00 20 blr
{
type = msdos_get_token(&path[i], strlen(&path[i]), &token, &token_len);
i += token_len;
fat_fd = pathloc->node_access;
switch (type)
ffc1ed24: 2f 83 00 03 cmpwi cr7,r3,3
ffc1ed28: 41 9e 00 20 beq- cr7,ffc1ed48 <msdos_eval4make+0x144> <== ALWAYS TAKEN
ffc1ed2c: 2f 83 00 04 cmpwi cr7,r3,4 <== NOT EXECUTED
ffc1ed30: 40 9e ff 50 bne+ cr7,ffc1ec80 <msdos_eval4make+0x7c> <== NOT EXECUTED
case MSDOS_CURRENT_DIR:
break;
case MSDOS_INVALID_TOKEN:
errno = ENAMETOOLONG;
ffc1ed34: 48 00 54 dd bl ffc24210 <__errno> <== NOT EXECUTED
ffc1ed38: 38 00 00 5b li r0,91 <== NOT EXECUTED
ffc1ed3c: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
rc = -1;
ffc1ed40: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
goto error;
ffc1ed44: 4b ff ff 94 b ffc1ecd8 <msdos_eval4make+0xd4> <== NOT EXECUTED
case MSDOS_NAME:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
ffc1ed48: 80 17 00 10 lwz r0,16(r23)
ffc1ed4c: 2f 80 00 01 cmpwi cr7,r0,1
ffc1ed50: 40 9e 01 a8 bne- cr7,ffc1eef8 <msdos_eval4make+0x2f4>
/*
* Otherwise find the token name in the present location and
* set the node access to the point we have found.
*/
rc = msdos_find_name(pathloc, token, token_len);
ffc1ed54: 80 81 00 08 lwz r4,8(r1)
ffc1ed58: 7f e3 fb 78 mr r3,r31
ffc1ed5c: 48 00 27 99 bl ffc214f4 <msdos_find_name>
if (rc)
ffc1ed60: 2c 03 00 00 cmpwi r3,0
ffc1ed64: 41 a2 ff 1c beq- ffc1ec80 <msdos_eval4make+0x7c>
{
if (rc != MSDOS_NAME_NOT_FOUND_ERR)
ffc1ed68: 2f 83 7d 01 cmpwi cr7,r3,32001
ffc1ed6c: 40 9e 00 44 bne- cr7,ffc1edb0 <msdos_eval4make+0x1ac> <== NEVER TAKEN
break;
}
}
*name = &path[i - token_len];
ffc1ed70: 80 01 00 0c lwz r0,12(r1)
/*
* We have evaluated the path as far as we can.
* Verify there is not any invalid stuff at the end of the name.
*/
for( ; path[i] != '\0'; i++)
ffc1ed74: 7d 3b f2 14 add r9,r27,r30
break;
}
}
*name = &path[i - token_len];
ffc1ed78: 7c 00 f0 50 subf r0,r0,r30
ffc1ed7c: 7c 1b 02 14 add r0,r27,r0
ffc1ed80: 90 1a 00 00 stw r0,0(r26)
/*
* 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++)
ffc1ed84: 7c 7b f0 ae lbzx r3,r27,r30
ffc1ed88: 2f 83 00 00 cmpwi cr7,r3,0
ffc1ed8c: 41 9e 01 2c beq- cr7,ffc1eeb8 <msdos_eval4make+0x2b4>
ffc1ed90: 7d 3e 4b 78 mr r30,r9
ffc1ed94: 48 00 00 10 b ffc1eda4 <msdos_eval4make+0x1a0>
ffc1ed98: 8c 7e 00 01 lbzu r3,1(r30)
ffc1ed9c: 2f 83 00 00 cmpwi cr7,r3,0
ffc1eda0: 41 9e 01 18 beq- cr7,ffc1eeb8 <msdos_eval4make+0x2b4>
{
if (!msdos_is_separator(path[i]))
ffc1eda4: 4b fe b6 41 bl ffc0a3e4 <rtems_filesystem_is_separator>
ffc1eda8: 2f 83 00 00 cmpwi cr7,r3,0
ffc1edac: 40 9e ff ec bne+ cr7,ffc1ed98 <msdos_eval4make+0x194>
{
errno = ENOENT;
ffc1edb0: 48 00 54 61 bl ffc24210 <__errno>
ffc1edb4: 38 00 00 02 li r0,2
ffc1edb8: 90 03 00 00 stw r0,0(r3)
rc = -1;
ffc1edbc: 3b 80 ff ff li r28,-1
goto error;
ffc1edc0: 4b ff ff 18 b ffc1ecd8 <msdos_eval4make+0xd4>
{
case MSDOS_UP_DIR:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
ffc1edc4: 80 17 00 10 lwz r0,16(r23)
ffc1edc8: 2f 80 00 01 cmpwi cr7,r0,1
ffc1edcc: 40 9e 01 2c bne- cr7,ffc1eef8 <msdos_eval4make+0x2f4> <== NEVER TAKEN
fat_file_close(pathloc->mt_entry, fat_fd);
err:
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
ffc1edd0: 81 3f 00 10 lwz r9,16(r31)
}
/*
* Am I at the root of this mounted filesystem?
*/
if (rtems_filesystem_is_root_location(pathloc))
ffc1edd4: 80 09 00 1c lwz r0,28(r9)
ffc1edd8: 7f 97 00 00 cmpw cr7,r23,r0
ffc1eddc: 41 9e 00 48 beq- cr7,ffc1ee24 <msdos_eval4make+0x220> <== ALWAYS TAKEN
pathloc, name);
}
}
else
{
rc = msdos_find_name(pathloc, token, token_len);
ffc1ede0: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
ffc1ede4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1ede8: 48 00 27 0d bl ffc214f4 <msdos_find_name> <== NOT EXECUTED
if (rc != RC_OK)
ffc1edec: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc1edf0: 41 82 fe 90 beq+ ffc1ec80 <msdos_eval4make+0x7c> <== NOT EXECUTED
{
if (rc == MSDOS_NAME_NOT_FOUND_ERR)
ffc1edf4: 2f 83 7d 01 cmpwi cr7,r3,32001 <== NOT EXECUTED
ffc1edf8: 7c 7c 1b 78 mr r28,r3 <== NOT EXECUTED
ffc1edfc: 40 9e fe dc bne+ cr7,ffc1ecd8 <msdos_eval4make+0xd4> <== NOT EXECUTED
{
errno = ENOENT;
ffc1ee00: 48 00 54 11 bl ffc24210 <__errno> <== NOT EXECUTED
rc = -1;
ffc1ee04: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
rc = msdos_find_name(pathloc, token, token_len);
if (rc != RC_OK)
{
if (rc == MSDOS_NAME_NOT_FOUND_ERR)
{
errno = ENOENT;
ffc1ee08: 93 03 00 00 stw r24,0(r3) <== NOT EXECUTED
ffc1ee0c: 4b ff fe cc b ffc1ecd8 <msdos_eval4make+0xd4> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
if (!pathloc->node_access)
{
errno = ENOENT;
ffc1ee10: 48 00 54 01 bl ffc24210 <__errno> <== NOT EXECUTED
ffc1ee14: 38 00 00 02 li r0,2 <== NOT EXECUTED
ffc1ee18: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
rc = -1;
ffc1ee1c: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
goto err;
ffc1ee20: 4b ff fe c4 b ffc1ece4 <msdos_eval4make+0xe0> <== NOT EXECUTED
/*
* Am I at the root of all filesystems?
* XXX: MSDOS is not supposed to be base fs.
*/
if (pathloc->node_access ==
rtems_filesystem_root.node_access)
ffc1ee24: 81 79 27 dc lwz r11,10204(r25)
{
/*
* Am I at the root of all filesystems?
* XXX: MSDOS is not supposed to be base fs.
*/
if (pathloc->node_access ==
ffc1ee28: 80 0b 00 18 lwz r0,24(r11)
ffc1ee2c: 7f 97 00 00 cmpw cr7,r23,r0
ffc1ee30: 41 9e fe 50 beq+ cr7,ffc1ec80 <msdos_eval4make+0x7c> <== ALWAYS TAKEN
{
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
ffc1ee34: 80 09 00 18 lwz r0,24(r9) <== NOT EXECUTED
*pathloc = newloc;
rc = fat_file_close(pathloc->mt_entry, fat_fd);
ffc1ee38: 7e e4 bb 78 mr r4,r23 <== NOT EXECUTED
{
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
ffc1ee3c: 81 09 00 08 lwz r8,8(r9) <== NOT EXECUTED
ffc1ee40: 81 49 00 0c lwz r10,12(r9) <== NOT EXECUTED
*pathloc = newloc;
rc = fat_file_close(pathloc->mt_entry, fat_fd);
ffc1ee44: 7c 03 03 78 mr r3,r0 <== NOT EXECUTED
{
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
ffc1ee48: 81 69 00 10 lwz r11,16(r9) <== NOT EXECUTED
ffc1ee4c: 81 29 00 14 lwz r9,20(r9) <== NOT EXECUTED
*pathloc = newloc;
ffc1ee50: 91 1f 00 00 stw r8,0(r31) <== NOT EXECUTED
ffc1ee54: 91 5f 00 04 stw r10,4(r31) <== NOT EXECUTED
ffc1ee58: 91 7f 00 08 stw r11,8(r31) <== NOT EXECUTED
ffc1ee5c: 91 3f 00 0c stw r9,12(r31) <== NOT EXECUTED
ffc1ee60: 90 1f 00 10 stw r0,16(r31) <== NOT EXECUTED
{
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
ffc1ee64: 91 01 00 10 stw r8,16(r1) <== NOT EXECUTED
ffc1ee68: 91 41 00 14 stw r10,20(r1) <== NOT EXECUTED
ffc1ee6c: 91 61 00 18 stw r11,24(r1) <== NOT EXECUTED
ffc1ee70: 91 21 00 1c stw r9,28(r1) <== NOT EXECUTED
ffc1ee74: 90 01 00 20 stw r0,32(r1) <== NOT EXECUTED
*pathloc = newloc;
rc = fat_file_close(pathloc->mt_entry, fat_fd);
ffc1ee78: 4b ff 8a 09 bl ffc17880 <fat_file_close> <== NOT EXECUTED
if (rc != RC_OK)
ffc1ee7c: 7c 7c 1b 79 mr. r28,r3 <== NOT EXECUTED
ffc1ee80: 40 82 fe 64 bne+ ffc1ece4 <msdos_eval4make+0xe0> <== NOT EXECUTED
goto err;
rtems_semaphore_release(fs_info->vol_sema);
ffc1ee84: 80 7d 00 98 lwz r3,152(r29) <== NOT EXECUTED
ffc1ee88: 4b fe ea 91 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
return (*pathloc->ops->evalformake_h)(&path[i-token_len],
ffc1ee8c: 81 3f 00 0c lwz r9,12(r31) <== NOT EXECUTED
ffc1ee90: 80 61 00 0c lwz r3,12(r1) <== NOT EXECUTED
ffc1ee94: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc1ee98: 80 09 00 04 lwz r0,4(r9) <== NOT EXECUTED
ffc1ee9c: 7f 45 d3 78 mr r5,r26 <== NOT EXECUTED
ffc1eea0: 7c 63 f0 50 subf r3,r3,r30 <== NOT EXECUTED
ffc1eea4: 7c 7b 1a 14 add r3,r27,r3 <== NOT EXECUTED
ffc1eea8: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc1eeac: 4e 80 04 21 bctrl <== NOT EXECUTED
ffc1eeb0: 7c 7c 1b 78 mr r28,r3 <== NOT EXECUTED
ffc1eeb4: 4b ff fe 38 b ffc1ecec <msdos_eval4make+0xe8> <== NOT EXECUTED
rc = -1;
goto error;
}
}
fat_fd = pathloc->node_access;
ffc1eeb8: 82 ff 00 00 lwz r23,0(r31)
if (fat_fd->fat_file_type != FAT_DIRECTORY)
ffc1eebc: 80 17 00 10 lwz r0,16(r23)
ffc1eec0: 2f 80 00 01 cmpwi cr7,r0,1
ffc1eec4: 40 9e 00 34 bne- cr7,ffc1eef8 <msdos_eval4make+0x2f4> <== NEVER TAKEN
* None
*/
static void
msdos_set_handlers(rtems_filesystem_location_info_t *loc)
{
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
ffc1eec8: 81 3f 00 10 lwz r9,16(r31)
goto error;
}
msdos_set_handlers(pathloc);
rtems_semaphore_release(fs_info->vol_sema);
ffc1eecc: 80 7d 00 98 lwz r3,152(r29)
{
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = loc->node_access;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
loc->handlers = fs_info->directory_handlers;
ffc1eed0: 81 29 00 34 lwz r9,52(r9)
ffc1eed4: 80 09 00 90 lwz r0,144(r9)
ffc1eed8: 90 1f 00 08 stw r0,8(r31)
goto error;
}
msdos_set_handlers(pathloc);
rtems_semaphore_release(fs_info->vol_sema);
ffc1eedc: 4b fe ea 3d bl ffc0d918 <rtems_semaphore_release>
return RC_OK;
ffc1eee0: 4b ff fe 0c b ffc1ecec <msdos_eval4make+0xe8>
bool done = false;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
ffc1eee4: 48 00 53 2d bl ffc24210 <__errno> <== NOT EXECUTED
ffc1eee8: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1eeec: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1eef0: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
ffc1eef4: 4b ff fd f8 b ffc1ecec <msdos_eval4make+0xe8> <== NOT EXECUTED
fat_fd = pathloc->node_access;
if (fat_fd->fat_file_type != FAT_DIRECTORY)
{
errno = ENOTDIR;
ffc1eef8: 48 00 53 19 bl ffc24210 <__errno>
ffc1eefc: 38 00 00 14 li r0,20
ffc1ef00: 90 03 00 00 stw r0,0(r3)
rc = -1;
ffc1ef04: 3b 80 ff ff li r28,-1
goto error;
ffc1ef08: 4b ff fd d0 b ffc1ecd8 <msdos_eval4make+0xd4>
ffc1e940 <msdos_eval_path>:
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
ffc1e940: 94 21 ff b0 stwu r1,-80(r1)
ffc1e944: 7c 08 02 a6 mflr r0
ffc1e948: 90 01 00 54 stw r0,84(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
rtems_filesystem_location_info_t newloc;
int i = 0;
int token_len = 0;
ffc1e94c: 38 00 00 00 li r0,0
rtems_filesystem_location_info_t *pathloc
)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
ffc1e950: 81 26 00 10 lwz r9,16(r6)
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
ffc1e954: 93 81 00 40 stw r28,64(r1)
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
ffc1e958: 83 89 00 34 lwz r28,52(r9)
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
ffc1e95c: 93 41 00 38 stw r26,56(r1)
ffc1e960: 7c 7a 1b 78 mr r26,r3
int i = 0;
int token_len = 0;
msdos_token_types_t type = MSDOS_CURRENT_DIR;
const char *token;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1e964: 80 7c 00 98 lwz r3,152(r28)
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
ffc1e968: 93 21 00 34 stw r25,52(r1)
ffc1e96c: 7c b9 2b 78 mr r25,r5
int i = 0;
int token_len = 0;
msdos_token_types_t type = MSDOS_CURRENT_DIR;
const char *token;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1e970: 38 a0 00 00 li r5,0
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
ffc1e974: 93 c1 00 48 stw r30,72(r1)
ffc1e978: 7c 9e 23 78 mr r30,r4
int i = 0;
int token_len = 0;
msdos_token_types_t type = MSDOS_CURRENT_DIR;
const char *token;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1e97c: 38 80 00 00 li r4,0
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
ffc1e980: 93 e1 00 4c stw r31,76(r1)
ffc1e984: 7c df 33 78 mr r31,r6
ffc1e988: 92 c1 00 28 stw r22,40(r1)
ffc1e98c: 92 e1 00 2c stw r23,44(r1)
ffc1e990: 93 01 00 30 stw r24,48(r1)
ffc1e994: 93 61 00 3c stw r27,60(r1)
ffc1e998: 93 a1 00 44 stw r29,68(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
rtems_filesystem_location_info_t newloc;
int i = 0;
int token_len = 0;
ffc1e99c: 90 01 00 0c stw r0,12(r1)
msdos_token_types_t type = MSDOS_CURRENT_DIR;
const char *token;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1e9a0: 4b fe ed ed bl ffc0d78c <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1e9a4: 2f 83 00 00 cmpwi cr7,r3,0
ffc1e9a8: 40 9e 02 34 bne- cr7,ffc1ebdc <msdos_eval_path+0x29c> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one(EIO);
if (!pathloc->node_access)
ffc1e9ac: 80 7f 00 00 lwz r3,0(r31)
ffc1e9b0: 2f 83 00 00 cmpwi cr7,r3,0
ffc1e9b4: 41 9e 01 70 beq- cr7,ffc1eb24 <msdos_eval_path+0x1e4> <== NEVER TAKEN
goto err;
}
fat_fd = pathloc->node_access;
rc = fat_file_reopen(fat_fd);
ffc1e9b8: 4b ff 8a e9 bl ffc174a0 <fat_file_reopen>
if (rc != RC_OK)
ffc1e9bc: 7c 7b 1b 79 mr. r27,r3
ffc1e9c0: 40 82 00 74 bne- ffc1ea34 <msdos_eval_path+0xf4> <== NEVER TAKEN
ffc1e9c4: 3b a0 00 00 li r29,0
/*
* Am I at the root of all filesystems?
* XXX: MSDOS is not supposed to be base fs.
*/
if (pathloc->node_access ==
rtems_filesystem_root.node_access)
ffc1e9c8: 3f 00 00 00 lis r24,0
if (rc != RC_OK)
goto err;
while ((type != MSDOS_NO_MORE_PATH) && (type != MSDOS_INVALID_TOKEN))
{
type = msdos_get_token(&pathname[i], pathnamelen, &token, &token_len);
ffc1e9cc: 7c 7a ea 14 add r3,r26,r29
ffc1e9d0: 7f c4 f3 78 mr r4,r30
ffc1e9d4: 38 a1 00 08 addi r5,r1,8
ffc1e9d8: 38 c1 00 0c addi r6,r1,12
ffc1e9dc: 48 00 11 f5 bl ffc1fbd0 <msdos_get_token>
pathnamelen -= token_len;
ffc1e9e0: 80 a1 00 0c lwz r5,12(r1)
i += token_len;
fat_fd = pathloc->node_access;
switch (type)
ffc1e9e4: 2f 83 00 03 cmpwi cr7,r3,3
{
type = msdos_get_token(&pathname[i], pathnamelen, &token, &token_len);
pathnamelen -= token_len;
i += token_len;
fat_fd = pathloc->node_access;
ffc1e9e8: 82 df 00 00 lwz r22,0(r31)
if (rc != RC_OK)
goto err;
while ((type != MSDOS_NO_MORE_PATH) && (type != MSDOS_INVALID_TOKEN))
{
type = msdos_get_token(&pathname[i], pathnamelen, &token, &token_len);
ffc1e9ec: 7c 77 1b 78 mr r23,r3
pathnamelen -= token_len;
ffc1e9f0: 7f c5 f0 50 subf r30,r5,r30
i += token_len;
ffc1e9f4: 7f bd 2a 14 add r29,r29,r5
fat_fd = pathloc->node_access;
switch (type)
ffc1e9f8: 41 9e 00 80 beq- cr7,ffc1ea78 <msdos_eval_path+0x138>
ffc1e9fc: 2f 83 00 04 cmpwi cr7,r3,4
ffc1ea00: 41 9e 01 04 beq- cr7,ffc1eb04 <msdos_eval_path+0x1c4> <== NEVER TAKEN
ffc1ea04: 2f 03 00 02 cmpwi cr6,r3,2
ffc1ea08: 41 9a 00 b0 beq- cr6,ffc1eab8 <msdos_eval_path+0x178>
rc = fat_file_reopen(fat_fd);
if (rc != RC_OK)
goto err;
while ((type != MSDOS_NO_MORE_PATH) && (type != MSDOS_INVALID_TOKEN))
ffc1ea0c: 2f 03 00 00 cmpwi cr6,r3,0
ffc1ea10: 41 9a 00 08 beq- cr6,ffc1ea18 <msdos_eval_path+0xd8>
ffc1ea14: 40 9e ff b8 bne+ cr7,ffc1e9cc <msdos_eval_path+0x8c> <== ALWAYS TAKEN
msdos_set_handlers(rtems_filesystem_location_info_t *loc)
{
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = loc->node_access;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
ffc1ea18: 80 16 00 10 lwz r0,16(r22)
* None
*/
static void
msdos_set_handlers(rtems_filesystem_location_info_t *loc)
{
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
ffc1ea1c: 81 3f 00 10 lwz r9,16(r31)
fat_file_fd_t *fat_fd = loc->node_access;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
ffc1ea20: 2f 80 00 01 cmpwi cr7,r0,1
* None
*/
static void
msdos_set_handlers(rtems_filesystem_location_info_t *loc)
{
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
ffc1ea24: 81 29 00 34 lwz r9,52(r9)
fat_file_fd_t *fat_fd = loc->node_access;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
ffc1ea28: 41 9e 01 a8 beq- cr7,ffc1ebd0 <msdos_eval_path+0x290>
loc->handlers = fs_info->directory_handlers;
else
loc->handlers = fs_info->file_handlers;
ffc1ea2c: 80 09 00 94 lwz r0,148(r9)
ffc1ea30: 90 1f 00 08 stw r0,8(r31)
error:
fat_file_close(pathloc->mt_entry, fat_fd);
err:
rtems_semaphore_release(fs_info->vol_sema);
ffc1ea34: 80 7c 00 98 lwz r3,152(r28)
ffc1ea38: 4b fe ee e1 bl ffc0d918 <rtems_semaphore_release>
return rc;
}
ffc1ea3c: 80 01 00 54 lwz r0,84(r1)
ffc1ea40: 7f 63 db 78 mr r3,r27
ffc1ea44: 82 c1 00 28 lwz r22,40(r1)
ffc1ea48: 7c 08 03 a6 mtlr r0
ffc1ea4c: 82 e1 00 2c lwz r23,44(r1)
ffc1ea50: 83 01 00 30 lwz r24,48(r1)
ffc1ea54: 83 21 00 34 lwz r25,52(r1)
ffc1ea58: 83 41 00 38 lwz r26,56(r1)
ffc1ea5c: 83 61 00 3c lwz r27,60(r1)
ffc1ea60: 83 81 00 40 lwz r28,64(r1)
ffc1ea64: 83 a1 00 44 lwz r29,68(r1)
ffc1ea68: 83 c1 00 48 lwz r30,72(r1)
ffc1ea6c: 83 e1 00 4c lwz r31,76(r1)
ffc1ea70: 38 21 00 50 addi r1,r1,80
ffc1ea74: 4e 80 00 20 blr
case MSDOS_NAME:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
ffc1ea78: 80 16 00 10 lwz r0,16(r22)
ffc1ea7c: 2f 80 00 01 cmpwi cr7,r0,1
ffc1ea80: 40 9e 01 70 bne- cr7,ffc1ebf0 <msdos_eval_path+0x2b0>
/*
* Otherwise find the token name in the present location and
* set the node access to the point we have found.
*/
rc = msdos_find_name(pathloc, token, token_len);
ffc1ea84: 80 81 00 08 lwz r4,8(r1)
ffc1ea88: 7f e3 fb 78 mr r3,r31
ffc1ea8c: 48 00 2a 69 bl ffc214f4 <msdos_find_name>
if (rc != RC_OK)
ffc1ea90: 2c 03 00 00 cmpwi r3,0
ffc1ea94: 41 82 ff 38 beq+ ffc1e9cc <msdos_eval_path+0x8c>
{
if (rc == MSDOS_NAME_NOT_FOUND_ERR)
ffc1ea98: 2f 83 7d 01 cmpwi cr7,r3,32001
ffc1ea9c: 7c 7b 1b 78 mr r27,r3
ffc1eaa0: 40 be 00 74 bne+ cr7,ffc1eb14 <msdos_eval_path+0x1d4>
{
errno = ENOENT;
ffc1eaa4: 48 00 57 6d bl ffc24210 <__errno>
ffc1eaa8: 38 00 00 02 li r0,2
ffc1eaac: 90 03 00 00 stw r0,0(r3)
rc = -1;
ffc1eab0: 3b 60 ff ff li r27,-1
ffc1eab4: 48 00 00 60 b ffc1eb14 <msdos_eval_path+0x1d4>
{
case MSDOS_UP_DIR:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
ffc1eab8: 80 16 00 10 lwz r0,16(r22)
ffc1eabc: 2f 80 00 01 cmpwi cr7,r0,1
ffc1eac0: 40 9e 01 30 bne- cr7,ffc1ebf0 <msdos_eval_path+0x2b0> <== NEVER TAKEN
fat_file_close(pathloc->mt_entry, fat_fd);
err:
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
ffc1eac4: 81 3f 00 10 lwz r9,16(r31)
}
/*
* Am I at the root of this mounted filesystem?
*/
if (rtems_filesystem_is_root_location(pathloc))
ffc1eac8: 80 09 00 1c lwz r0,28(r9)
ffc1eacc: 7f 96 00 00 cmpw cr7,r22,r0
ffc1ead0: 41 9e 00 68 beq- cr7,ffc1eb38 <msdos_eval_path+0x1f8> <== NEVER TAKEN
flags, pathloc);
}
}
else
{
rc = msdos_find_name(pathloc, token, token_len);
ffc1ead4: 80 81 00 08 lwz r4,8(r1)
ffc1ead8: 7f e3 fb 78 mr r3,r31
ffc1eadc: 48 00 2a 19 bl ffc214f4 <msdos_find_name>
if (rc != RC_OK)
ffc1eae0: 2c 03 00 00 cmpwi r3,0
ffc1eae4: 41 82 fe e8 beq+ ffc1e9cc <msdos_eval_path+0x8c> <== ALWAYS TAKEN
{
if (rc == MSDOS_NAME_NOT_FOUND_ERR)
ffc1eae8: 2f 83 7d 01 cmpwi cr7,r3,32001 <== NOT EXECUTED
ffc1eaec: 7c 7b 1b 78 mr r27,r3 <== NOT EXECUTED
ffc1eaf0: 40 be 00 24 bne+ cr7,ffc1eb14 <msdos_eval_path+0x1d4> <== NOT EXECUTED
{
errno = ENOENT;
ffc1eaf4: 48 00 57 1d bl ffc24210 <__errno> <== NOT EXECUTED
rc = -1;
ffc1eaf8: 3b 60 ff ff li r27,-1 <== NOT EXECUTED
rc = msdos_find_name(pathloc, token, token_len);
if (rc != RC_OK)
{
if (rc == MSDOS_NAME_NOT_FOUND_ERR)
{
errno = ENOENT;
ffc1eafc: 92 e3 00 00 stw r23,0(r3) <== NOT EXECUTED
ffc1eb00: 48 00 00 14 b ffc1eb14 <msdos_eval_path+0x1d4> <== NOT EXECUTED
case MSDOS_NO_MORE_PATH:
case MSDOS_CURRENT_DIR:
break;
case MSDOS_INVALID_TOKEN:
errno = ENAMETOOLONG;
ffc1eb04: 48 00 57 0d bl ffc24210 <__errno> <== NOT EXECUTED
ffc1eb08: 38 00 00 5b li r0,91 <== NOT EXECUTED
ffc1eb0c: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
rc = -1;
ffc1eb10: 3b 60 ff ff li r27,-1 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return RC_OK;
error:
fat_file_close(pathloc->mt_entry, fat_fd);
ffc1eb14: 80 7f 00 10 lwz r3,16(r31)
ffc1eb18: 7e c4 b3 78 mr r4,r22
ffc1eb1c: 4b ff 8d 65 bl ffc17880 <fat_file_close>
ffc1eb20: 4b ff ff 14 b ffc1ea34 <msdos_eval_path+0xf4>
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
if (!pathloc->node_access)
{
errno = ENOENT;
ffc1eb24: 48 00 56 ed bl ffc24210 <__errno> <== NOT EXECUTED
ffc1eb28: 38 00 00 02 li r0,2 <== NOT EXECUTED
ffc1eb2c: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
rc = -1;
ffc1eb30: 3b 60 ff ff li r27,-1 <== NOT EXECUTED
goto err;
ffc1eb34: 4b ff ff 00 b ffc1ea34 <msdos_eval_path+0xf4> <== NOT EXECUTED
/*
* Am I at the root of all filesystems?
* XXX: MSDOS is not supposed to be base fs.
*/
if (pathloc->node_access ==
rtems_filesystem_root.node_access)
ffc1eb38: 81 78 27 dc lwz r11,10204(r24) <== NOT EXECUTED
{
/*
* Am I at the root of all filesystems?
* XXX: MSDOS is not supposed to be base fs.
*/
if (pathloc->node_access ==
ffc1eb3c: 80 0b 00 18 lwz r0,24(r11) <== NOT EXECUTED
ffc1eb40: 7f 96 00 00 cmpw cr7,r22,r0 <== NOT EXECUTED
ffc1eb44: 41 9e fe 88 beq+ cr7,ffc1e9cc <msdos_eval_path+0x8c> <== NOT EXECUTED
{
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
ffc1eb48: 80 09 00 18 lwz r0,24(r9) <== NOT EXECUTED
*pathloc = newloc;
rc = fat_file_close(pathloc->mt_entry, fat_fd);
ffc1eb4c: 7e c4 b3 78 mr r4,r22 <== NOT EXECUTED
{
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
ffc1eb50: 81 09 00 08 lwz r8,8(r9) <== NOT EXECUTED
ffc1eb54: 81 49 00 0c lwz r10,12(r9) <== NOT EXECUTED
*pathloc = newloc;
rc = fat_file_close(pathloc->mt_entry, fat_fd);
ffc1eb58: 7c 03 03 78 mr r3,r0 <== NOT EXECUTED
{
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
ffc1eb5c: 81 69 00 10 lwz r11,16(r9) <== NOT EXECUTED
ffc1eb60: 81 29 00 14 lwz r9,20(r9) <== NOT EXECUTED
*pathloc = newloc;
ffc1eb64: 91 1f 00 00 stw r8,0(r31) <== NOT EXECUTED
ffc1eb68: 91 5f 00 04 stw r10,4(r31) <== NOT EXECUTED
ffc1eb6c: 91 7f 00 08 stw r11,8(r31) <== NOT EXECUTED
ffc1eb70: 91 3f 00 0c stw r9,12(r31) <== NOT EXECUTED
ffc1eb74: 90 1f 00 10 stw r0,16(r31) <== NOT EXECUTED
{
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
ffc1eb78: 91 01 00 10 stw r8,16(r1) <== NOT EXECUTED
ffc1eb7c: 91 41 00 14 stw r10,20(r1) <== NOT EXECUTED
ffc1eb80: 91 61 00 18 stw r11,24(r1) <== NOT EXECUTED
ffc1eb84: 91 21 00 1c stw r9,28(r1) <== NOT EXECUTED
ffc1eb88: 90 01 00 20 stw r0,32(r1) <== NOT EXECUTED
*pathloc = newloc;
rc = fat_file_close(pathloc->mt_entry, fat_fd);
ffc1eb8c: 4b ff 8c f5 bl ffc17880 <fat_file_close> <== NOT EXECUTED
if (rc != RC_OK)
ffc1eb90: 7c 7b 1b 79 mr. r27,r3 <== NOT EXECUTED
ffc1eb94: 40 82 fe a0 bne+ ffc1ea34 <msdos_eval_path+0xf4> <== NOT EXECUTED
goto err;
rtems_semaphore_release(fs_info->vol_sema);
ffc1eb98: 80 7c 00 98 lwz r3,152(r28) <== NOT EXECUTED
ffc1eb9c: 4b fe ed 7d bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
return (*pathloc->ops->evalpath_h)(&(pathname[i-token_len]),
ffc1eba0: 81 3f 00 0c lwz r9,12(r31) <== NOT EXECUTED
ffc1eba4: 80 81 00 0c lwz r4,12(r1) <== NOT EXECUTED
ffc1eba8: 7f 25 cb 78 mr r5,r25 <== NOT EXECUTED
ffc1ebac: 80 09 00 00 lwz r0,0(r9) <== NOT EXECUTED
ffc1ebb0: 7f e6 fb 78 mr r6,r31 <== NOT EXECUTED
ffc1ebb4: 7c 64 e8 50 subf r3,r4,r29 <== NOT EXECUTED
ffc1ebb8: 7c 7a 1a 14 add r3,r26,r3 <== NOT EXECUTED
ffc1ebbc: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc1ebc0: 7c 9e 22 14 add r4,r30,r4 <== NOT EXECUTED
ffc1ebc4: 4e 80 04 21 bctrl <== NOT EXECUTED
ffc1ebc8: 7c 7b 1b 78 mr r27,r3 <== NOT EXECUTED
ffc1ebcc: 4b ff fe 70 b ffc1ea3c <msdos_eval_path+0xfc> <== NOT EXECUTED
{
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = loc->node_access;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
loc->handlers = fs_info->directory_handlers;
ffc1ebd0: 80 09 00 90 lwz r0,144(r9)
ffc1ebd4: 90 1f 00 08 stw r0,8(r31)
ffc1ebd8: 4b ff fe 5c b ffc1ea34 <msdos_eval_path+0xf4>
const char *token;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
ffc1ebdc: 48 00 56 35 bl ffc24210 <__errno> <== NOT EXECUTED
ffc1ebe0: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1ebe4: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1ebe8: 3b 60 ff ff li r27,-1 <== NOT EXECUTED
ffc1ebec: 4b ff fe 50 b ffc1ea3c <msdos_eval_path+0xfc> <== NOT EXECUTED
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
{
errno = ENOTSUP;
ffc1ebf0: 48 00 56 21 bl ffc24210 <__errno>
ffc1ebf4: 38 00 00 86 li r0,134
ffc1ebf8: 90 03 00 00 stw r0,0(r3)
rc = -1;
ffc1ebfc: 3b 60 ff ff li r27,-1
goto error;
ffc1ec00: 4b ff ff 14 b ffc1eb14 <msdos_eval_path+0x1d4>
ffc1f738 <msdos_file_chmod>:
int
msdos_file_chmod(rtems_filesystem_location_info_t *pathloc,
mode_t mode)
{
return RC_OK;
}
ffc1f738: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1f73c: 4e 80 00 20 blr <== NOT EXECUTED
ffc1efc8 <msdos_file_close>:
* RC_OK, if file closed successfully, or -1 if error occured (errno set
* appropriately)
*/
int
msdos_file_close(rtems_libio_t *iop)
{
ffc1efc8: 94 21 ff e8 stwu r1,-24(r1)
ffc1efcc: 7c 08 02 a6 mflr r0
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1efd0: 38 80 00 00 li r4,0
* RC_OK, if file closed successfully, or -1 if error occured (errno set
* appropriately)
*/
int
msdos_file_close(rtems_libio_t *iop)
{
ffc1efd4: 90 01 00 1c stw r0,28(r1)
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1efd8: 38 a0 00 00 li r5,0
int
msdos_file_close(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
ffc1efdc: 81 23 00 2c lwz r9,44(r3)
* RC_OK, if file closed successfully, or -1 if error occured (errno set
* appropriately)
*/
int
msdos_file_close(rtems_libio_t *iop)
{
ffc1efe0: 93 a1 00 0c stw r29,12(r1)
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
ffc1efe4: 83 a9 00 34 lwz r29,52(r9)
* RC_OK, if file closed successfully, or -1 if error occured (errno set
* appropriately)
*/
int
msdos_file_close(rtems_libio_t *iop)
{
ffc1efe8: 93 e1 00 14 stw r31,20(r1)
ffc1efec: 7c 7f 1b 78 mr r31,r3
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1eff0: 80 7d 00 98 lwz r3,152(r29)
* RC_OK, if file closed successfully, or -1 if error occured (errno set
* appropriately)
*/
int
msdos_file_close(rtems_libio_t *iop)
{
ffc1eff4: 93 c1 00 10 stw r30,16(r1)
ffc1eff8: 93 81 00 08 stw r28,8(r1)
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
ffc1effc: 83 df 00 1c lwz r30,28(r31)
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f000: 4b fe e7 8d bl ffc0d78c <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1f004: 2f 83 00 00 cmpwi cr7,r3,0
ffc1f008: 40 9e 00 8c bne- cr7,ffc1f094 <msdos_file_close+0xcc> <== NEVER TAKEN
/*
* if fat-file descriptor is not marked as "removed", synchronize
* size, first cluster number, write time and date fields of the file
*/
if (!FAT_FILE_IS_REMOVED(fat_fd))
ffc1f00c: 88 1e 00 30 lbz r0,48(r30)
ffc1f010: 70 09 00 01 andi. r9,r0,1
ffc1f014: 41 82 00 40 beq- ffc1f054 <msdos_file_close+0x8c> <== ALWAYS TAKEN
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
rc = fat_file_close(iop->pathinfo.mt_entry, fat_fd);
ffc1f018: 80 7f 00 2c lwz r3,44(r31)
ffc1f01c: 7f c4 f3 78 mr r4,r30
ffc1f020: 4b ff 88 61 bl ffc17880 <fat_file_close>
ffc1f024: 7c 7c 1b 78 mr r28,r3
rtems_semaphore_release(fs_info->vol_sema);
ffc1f028: 80 7d 00 98 lwz r3,152(r29)
ffc1f02c: 4b fe e8 ed bl ffc0d918 <rtems_semaphore_release>
return rc;
}
ffc1f030: 80 01 00 1c lwz r0,28(r1)
ffc1f034: 7f 83 e3 78 mr r3,r28
ffc1f038: 83 a1 00 0c lwz r29,12(r1)
ffc1f03c: 7c 08 03 a6 mtlr r0
ffc1f040: 83 81 00 08 lwz r28,8(r1)
ffc1f044: 83 c1 00 10 lwz r30,16(r1)
ffc1f048: 83 e1 00 14 lwz r31,20(r1)
ffc1f04c: 38 21 00 18 addi r1,r1,24
ffc1f050: 4e 80 00 20 blr
* if fat-file descriptor is not marked as "removed", synchronize
* size, first cluster number, write time and date fields of the file
*/
if (!FAT_FILE_IS_REMOVED(fat_fd))
{
rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
ffc1f054: 80 7f 00 2c lwz r3,44(r31)
ffc1f058: 7f c4 f3 78 mr r4,r30
ffc1f05c: 48 00 0e 15 bl ffc1fe70 <msdos_set_first_cluster_num>
if (rc != RC_OK)
ffc1f060: 7c 7c 1b 79 mr. r28,r3
ffc1f064: 40 a2 ff c4 bne- ffc1f028 <msdos_file_close+0x60> <== NEVER TAKEN
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
ffc1f068: 80 7f 00 2c lwz r3,44(r31)
ffc1f06c: 7f c4 f3 78 mr r4,r30
ffc1f070: 48 00 0f 19 bl ffc1ff88 <msdos_set_file_size>
if (rc != RC_OK)
ffc1f074: 7c 7c 1b 79 mr. r28,r3
ffc1f078: 40 a2 ff b0 bne- ffc1f028 <msdos_file_close+0x60> <== NEVER TAKEN
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
ffc1f07c: 80 7f 00 2c lwz r3,44(r31)
ffc1f080: 7f c4 f3 78 mr r4,r30
ffc1f084: 48 00 0c a5 bl ffc1fd28 <msdos_set_dir_wrt_time_and_date>
if (rc != RC_OK)
ffc1f088: 7c 7c 1b 79 mr. r28,r3
ffc1f08c: 41 82 ff 8c beq+ ffc1f018 <msdos_file_close+0x50> <== ALWAYS TAKEN
ffc1f090: 4b ff ff 98 b ffc1f028 <msdos_file_close+0x60> <== NOT EXECUTED
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
ffc1f094: 48 00 51 7d bl ffc24210 <__errno> <== NOT EXECUTED
ffc1f098: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1f09c: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1f0a0: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
ffc1f0a4: 4b ff ff 8c b ffc1f030 <msdos_file_close+0x68> <== NOT EXECUTED
ffc1f6a8 <msdos_file_datasync>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_datasync(rtems_libio_t *iop)
{
ffc1f6a8: 94 21 ff e8 stwu r1,-24(r1) <== NOT EXECUTED
ffc1f6ac: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f6b0: 38 80 00 00 li r4,0 <== NOT EXECUTED
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_datasync(rtems_libio_t *iop)
{
ffc1f6b4: 90 01 00 1c stw r0,28(r1) <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f6b8: 38 a0 00 00 li r5,0 <== NOT EXECUTED
msdos_file_datasync(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
ffc1f6bc: 81 23 00 2c lwz r9,44(r3) <== NOT EXECUTED
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_datasync(rtems_libio_t *iop)
{
ffc1f6c0: 93 c1 00 10 stw r30,16(r1) <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
ffc1f6c4: 83 c9 00 34 lwz r30,52(r9) <== NOT EXECUTED
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_datasync(rtems_libio_t *iop)
{
ffc1f6c8: 93 e1 00 14 stw r31,20(r1) <== NOT EXECUTED
ffc1f6cc: 7c 7f 1b 78 mr r31,r3 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f6d0: 80 7e 00 98 lwz r3,152(r30) <== NOT EXECUTED
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_datasync(rtems_libio_t *iop)
{
ffc1f6d4: 93 a1 00 0c stw r29,12(r1) <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
ffc1f6d8: 83 bf 00 1c lwz r29,28(r31) <== NOT EXECUTED
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f6dc: 4b fe e0 b1 bl ffc0d78c <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1f6e0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1f6e4: 40 9e 00 38 bne- cr7,ffc1f71c <msdos_file_datasync+0x74><== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
/* synchronize file data */
rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);
ffc1f6e8: 80 7f 00 2c lwz r3,44(r31) <== NOT EXECUTED
ffc1f6ec: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc1f6f0: 4b ff 89 41 bl ffc18030 <fat_file_datasync> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
ffc1f6f4: 80 7e 00 98 lwz r3,152(r30) <== NOT EXECUTED
ffc1f6f8: 4b fe e2 21 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
return RC_OK;
ffc1f6fc: 38 60 00 00 li r3,0 <== NOT EXECUTED
}
ffc1f700: 80 01 00 1c lwz r0,28(r1) <== NOT EXECUTED
ffc1f704: 83 a1 00 0c lwz r29,12(r1) <== NOT EXECUTED
ffc1f708: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc1f70c: 83 c1 00 10 lwz r30,16(r1) <== NOT EXECUTED
ffc1f710: 83 e1 00 14 lwz r31,20(r1) <== NOT EXECUTED
ffc1f714: 38 21 00 18 addi r1,r1,24 <== NOT EXECUTED
ffc1f718: 4e 80 00 20 blr <== NOT EXECUTED
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
ffc1f71c: 48 00 4a f5 bl ffc24210 <__errno> <== NOT EXECUTED
ffc1f720: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1f724: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1f728: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc1f72c: 4b ff ff d4 b ffc1f700 <msdos_file_datasync+0x58> <== NOT EXECUTED
ffc1f454 <msdos_file_ftruncate>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately).
*/
int
msdos_file_ftruncate(rtems_libio_t *iop, rtems_off64_t length)
{
ffc1f454: 94 21 ff e0 stwu r1,-32(r1)
ffc1f458: 7c 08 02 a6 mflr r0
ffc1f45c: 90 01 00 24 stw r0,36(r1)
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
if (length >= fat_fd->fat_file_size)
ffc1f460: 38 00 00 00 li r0,0
ffc1f464: 7f 80 28 00 cmpw cr7,r0,r5
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately).
*/
int
msdos_file_ftruncate(rtems_libio_t *iop, rtems_off64_t length)
{
ffc1f468: 93 c1 00 18 stw r30,24(r1)
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
ffc1f46c: 81 23 00 2c lwz r9,44(r3)
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
ffc1f470: 83 c3 00 1c lwz r30,28(r3)
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately).
*/
int
msdos_file_ftruncate(rtems_libio_t *iop, rtems_off64_t length)
{
ffc1f474: 93 61 00 0c stw r27,12(r1)
ffc1f478: 93 81 00 10 stw r28,16(r1)
ffc1f47c: 7c dc 33 78 mr r28,r6
ffc1f480: 93 a1 00 14 stw r29,20(r1)
ffc1f484: 7c bd 2b 78 mr r29,r5
ffc1f488: 93 e1 00 1c stw r31,28(r1)
ffc1f48c: 7c 7f 1b 78 mr r31,r3
ffc1f490: 93 41 00 08 stw r26,8(r1)
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
ffc1f494: 83 69 00 34 lwz r27,52(r9)
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
if (length >= fat_fd->fat_file_size)
ffc1f498: 80 1e 00 18 lwz r0,24(r30)
ffc1f49c: 41 9d 00 40 bgt- cr7,ffc1f4dc <msdos_file_ftruncate+0x88><== NEVER TAKEN
ffc1f4a0: 41 9e 00 34 beq- cr7,ffc1f4d4 <msdos_file_ftruncate+0x80><== ALWAYS TAKEN
return RC_OK;
ffc1f4a4: 3b 40 00 00 li r26,0
if (length < fat_fd->fat_file_size)
iop->size = fat_fd->fat_file_size = length;
rtems_semaphore_release(fs_info->vol_sema);
return RC_OK;
}
ffc1f4a8: 80 01 00 24 lwz r0,36(r1)
ffc1f4ac: 7f 43 d3 78 mr r3,r26
ffc1f4b0: 83 61 00 0c lwz r27,12(r1)
ffc1f4b4: 7c 08 03 a6 mtlr r0
ffc1f4b8: 83 41 00 08 lwz r26,8(r1)
ffc1f4bc: 83 81 00 10 lwz r28,16(r1)
ffc1f4c0: 83 a1 00 14 lwz r29,20(r1)
ffc1f4c4: 83 c1 00 18 lwz r30,24(r1)
ffc1f4c8: 83 e1 00 1c lwz r31,28(r1)
ffc1f4cc: 38 21 00 20 addi r1,r1,32
ffc1f4d0: 4e 80 00 20 blr
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
if (length >= fat_fd->fat_file_size)
ffc1f4d4: 7f 80 30 40 cmplw cr7,r0,r6
ffc1f4d8: 40 9d ff cc ble+ cr7,ffc1f4a4 <msdos_file_ftruncate+0x50>
return RC_OK;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f4dc: 80 7b 00 98 lwz r3,152(r27)
ffc1f4e0: 38 80 00 00 li r4,0
ffc1f4e4: 38 a0 00 00 li r5,0
ffc1f4e8: 4b fe e2 a5 bl ffc0d78c <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1f4ec: 2f 83 00 00 cmpwi cr7,r3,0
ffc1f4f0: 40 9e 00 78 bne- cr7,ffc1f568 <msdos_file_ftruncate+0x114><== NEVER TAKEN
rtems_set_errno_and_return_minus_one(EIO);
rc = fat_file_truncate(iop->pathinfo.mt_entry, fat_fd, length);
ffc1f4f4: 80 7f 00 2c lwz r3,44(r31)
ffc1f4f8: 7f c4 f3 78 mr r4,r30
ffc1f4fc: 7f 85 e3 78 mr r5,r28
ffc1f500: 4b ff 82 19 bl ffc17718 <fat_file_truncate>
if (rc != RC_OK)
ffc1f504: 7c 7a 1b 79 mr. r26,r3
ffc1f508: 40 82 00 2c bne- ffc1f534 <msdos_file_ftruncate+0xe0> <== NEVER TAKEN
/*
* fat_file_truncate do nothing if new length >= fat-file size, so update
* file size only if length < fat-file size
*/
if (length < fat_fd->fat_file_size)
ffc1f50c: 7f 9a e8 00 cmpw cr7,r26,r29
ffc1f510: 80 1e 00 18 lwz r0,24(r30)
ffc1f514: 41 9d 00 10 bgt- cr7,ffc1f524 <msdos_file_ftruncate+0xd0><== NEVER TAKEN
ffc1f518: 40 9e 00 1c bne- cr7,ffc1f534 <msdos_file_ftruncate+0xe0><== NEVER TAKEN
ffc1f51c: 7f 80 e0 40 cmplw cr7,r0,r28
ffc1f520: 40 9d 00 14 ble- cr7,ffc1f534 <msdos_file_ftruncate+0xe0><== NEVER TAKEN
iop->size = fat_fd->fat_file_size = length;
ffc1f524: 38 00 00 00 li r0,0
ffc1f528: 93 9e 00 18 stw r28,24(r30)
ffc1f52c: 93 9f 00 0c stw r28,12(r31)
ffc1f530: 90 1f 00 08 stw r0,8(r31)
rtems_semaphore_release(fs_info->vol_sema);
ffc1f534: 80 7b 00 98 lwz r3,152(r27)
ffc1f538: 4b fe e3 e1 bl ffc0d918 <rtems_semaphore_release>
return RC_OK;
}
ffc1f53c: 80 01 00 24 lwz r0,36(r1)
ffc1f540: 7f 43 d3 78 mr r3,r26
ffc1f544: 83 61 00 0c lwz r27,12(r1)
ffc1f548: 7c 08 03 a6 mtlr r0
ffc1f54c: 83 41 00 08 lwz r26,8(r1)
ffc1f550: 83 81 00 10 lwz r28,16(r1)
ffc1f554: 83 a1 00 14 lwz r29,20(r1)
ffc1f558: 83 c1 00 18 lwz r30,24(r1)
ffc1f55c: 83 e1 00 1c lwz r31,28(r1)
ffc1f560: 38 21 00 20 addi r1,r1,32
ffc1f564: 4e 80 00 20 blr
return RC_OK;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
ffc1f568: 48 00 4c a9 bl ffc24210 <__errno> <== NOT EXECUTED
ffc1f56c: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1f570: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1f574: 3b 40 ff ff li r26,-1 <== NOT EXECUTED
ffc1f578: 4b ff ff 30 b ffc1f4a8 <msdos_file_ftruncate+0x54> <== NOT EXECUTED
ffc1f730 <msdos_file_ioctl>:
msdos_file_ioctl(rtems_libio_t *iop,uint32_t command, void *buffer)
{
int rc = RC_OK;
return rc;
}
ffc1f730: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1f734: 4e 80 00 20 blr <== NOT EXECUTED
ffc1f268 <msdos_file_lseek>:
* new offset on success, or -1 if error occured (errno set
* appropriately).
*/
rtems_off64_t
msdos_file_lseek(rtems_libio_t *iop, rtems_off64_t offset, int whence)
{
ffc1f268: 94 21 ff d8 stwu r1,-40(r1)
ffc1f26c: 7c 08 02 a6 mflr r0
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
uint32_t real_size = 0;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f270: 38 80 00 00 li r4,0
* new offset on success, or -1 if error occured (errno set
* appropriately).
*/
rtems_off64_t
msdos_file_lseek(rtems_libio_t *iop, rtems_off64_t offset, int whence)
{
ffc1f274: 90 01 00 2c stw r0,44(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
uint32_t real_size = 0;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f278: 38 a0 00 00 li r5,0
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
uint32_t real_size = 0;
ffc1f27c: 38 00 00 00 li r0,0
rtems_off64_t
msdos_file_lseek(rtems_libio_t *iop, rtems_off64_t offset, int whence)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
ffc1f280: 81 23 00 2c lwz r9,44(r3)
* new offset on success, or -1 if error occured (errno set
* appropriately).
*/
rtems_off64_t
msdos_file_lseek(rtems_libio_t *iop, rtems_off64_t offset, int whence)
{
ffc1f284: 93 a1 00 1c stw r29,28(r1)
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
ffc1f288: 83 a9 00 34 lwz r29,52(r9)
* new offset on success, or -1 if error occured (errno set
* appropriately).
*/
rtems_off64_t
msdos_file_lseek(rtems_libio_t *iop, rtems_off64_t offset, int whence)
{
ffc1f28c: 93 e1 00 24 stw r31,36(r1)
ffc1f290: 7c 7f 1b 78 mr r31,r3
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
uint32_t real_size = 0;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f294: 80 7d 00 98 lwz r3,152(r29)
* new offset on success, or -1 if error occured (errno set
* appropriately).
*/
rtems_off64_t
msdos_file_lseek(rtems_libio_t *iop, rtems_off64_t offset, int whence)
{
ffc1f298: 93 c1 00 20 stw r30,32(r1)
ffc1f29c: 93 81 00 18 stw r28,24(r1)
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
ffc1f2a0: 83 df 00 1c lwz r30,28(r31)
uint32_t real_size = 0;
ffc1f2a4: 90 01 00 08 stw r0,8(r1)
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f2a8: 4b fe e4 e5 bl ffc0d78c <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1f2ac: 2f 83 00 00 cmpwi cr7,r3,0
ffc1f2b0: 40 9e 00 b4 bne- cr7,ffc1f364 <msdos_file_lseek+0xfc> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one(EIO);
rc = fat_file_extend(iop->pathinfo.mt_entry, fat_fd, iop->offset,
ffc1f2b4: 80 7f 00 2c lwz r3,44(r31)
ffc1f2b8: 7f c4 f3 78 mr r4,r30
ffc1f2bc: 80 bf 00 14 lwz r5,20(r31)
ffc1f2c0: 38 c1 00 08 addi r6,r1,8
ffc1f2c4: 4b ff 87 bd bl ffc17a80 <fat_file_extend>
&real_size);
if (rc != RC_OK)
ffc1f2c8: 7c 7c 1b 79 mr. r28,r3
ffc1f2cc: 40 82 00 68 bne- ffc1f334 <msdos_file_lseek+0xcc> <== NEVER TAKEN
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
if (real_size > fat_fd->fat_file_size)
ffc1f2d0: 81 3e 00 18 lwz r9,24(r30)
ffc1f2d4: 80 01 00 08 lwz r0,8(r1)
ffc1f2d8: 7f 89 00 40 cmplw cr7,r9,r0
ffc1f2dc: 41 9c 00 44 blt- cr7,ffc1f320 <msdos_file_lseek+0xb8> <== NEVER TAKEN
ffc1f2e0: 7d 20 4b 78 mr r0,r9
ffc1f2e4: 39 20 00 00 li r9,0
fat_fd->fat_file_size = iop->offset = real_size;
iop->size = fat_fd->fat_file_size;
ffc1f2e8: 91 3f 00 08 stw r9,8(r31)
ffc1f2ec: 90 1f 00 0c stw r0,12(r31)
rtems_semaphore_release(fs_info->vol_sema);
ffc1f2f0: 80 7d 00 98 lwz r3,152(r29)
ffc1f2f4: 4b fe e6 25 bl ffc0d918 <rtems_semaphore_release>
return iop->offset;
ffc1f2f8: 80 7f 00 10 lwz r3,16(r31)
ffc1f2fc: 80 9f 00 14 lwz r4,20(r31)
}
ffc1f300: 80 01 00 2c lwz r0,44(r1)
ffc1f304: 83 81 00 18 lwz r28,24(r1)
ffc1f308: 7c 08 03 a6 mtlr r0
ffc1f30c: 83 a1 00 1c lwz r29,28(r1)
ffc1f310: 83 c1 00 20 lwz r30,32(r1)
ffc1f314: 83 e1 00 24 lwz r31,36(r1)
ffc1f318: 38 21 00 28 addi r1,r1,40
ffc1f31c: 4e 80 00 20 blr
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
if (real_size > fat_fd->fat_file_size)
fat_fd->fat_file_size = iop->offset = real_size;
ffc1f320: 39 20 00 00 li r9,0 <== NOT EXECUTED
ffc1f324: 90 1f 00 14 stw r0,20(r31) <== NOT EXECUTED
ffc1f328: 91 3f 00 10 stw r9,16(r31) <== NOT EXECUTED
ffc1f32c: 90 1e 00 18 stw r0,24(r30) <== NOT EXECUTED
ffc1f330: 4b ff ff b8 b ffc1f2e8 <msdos_file_lseek+0x80> <== NOT EXECUTED
rc = fat_file_extend(iop->pathinfo.mt_entry, fat_fd, iop->offset,
&real_size);
if (rc != RC_OK)
{
rtems_semaphore_release(fs_info->vol_sema);
ffc1f334: 80 7d 00 98 lwz r3,152(r29) <== NOT EXECUTED
ffc1f338: 4b fe e5 e1 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
iop->size = fat_fd->fat_file_size;
rtems_semaphore_release(fs_info->vol_sema);
return iop->offset;
}
ffc1f33c: 80 01 00 2c lwz r0,44(r1) <== NOT EXECUTED
rc = fat_file_extend(iop->pathinfo.mt_entry, fat_fd, iop->offset,
&real_size);
if (rc != RC_OK)
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
ffc1f340: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
iop->size = fat_fd->fat_file_size;
rtems_semaphore_release(fs_info->vol_sema);
return iop->offset;
}
ffc1f344: 83 a1 00 1c lwz r29,28(r1) <== NOT EXECUTED
ffc1f348: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
rc = fat_file_extend(iop->pathinfo.mt_entry, fat_fd, iop->offset,
&real_size);
if (rc != RC_OK)
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
ffc1f34c: 7f 83 fe 70 srawi r3,r28,31 <== NOT EXECUTED
iop->size = fat_fd->fat_file_size;
rtems_semaphore_release(fs_info->vol_sema);
return iop->offset;
}
ffc1f350: 83 c1 00 20 lwz r30,32(r1) <== NOT EXECUTED
ffc1f354: 83 81 00 18 lwz r28,24(r1) <== NOT EXECUTED
ffc1f358: 83 e1 00 24 lwz r31,36(r1) <== NOT EXECUTED
ffc1f35c: 38 21 00 28 addi r1,r1,40 <== NOT EXECUTED
ffc1f360: 4e 80 00 20 blr <== NOT EXECUTED
uint32_t real_size = 0;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
ffc1f364: 48 00 4e ad bl ffc24210 <__errno> <== NOT EXECUTED
ffc1f368: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1f36c: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1f370: 38 80 ff ff li r4,-1 <== NOT EXECUTED
ffc1f374: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc1f378: 4b ff ff 88 b ffc1f300 <msdos_file_lseek+0x98> <== NOT EXECUTED
ffc1ef0c <msdos_file_open>:
* and errno set appropriately
*/
int
msdos_file_open(rtems_libio_t *iop, const char *pathname, uint32_t flag,
uint32_t mode)
{
ffc1ef0c: 94 21 ff e8 stwu r1,-24(r1)
ffc1ef10: 7c 08 02 a6 mflr r0
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1ef14: 38 80 00 00 li r4,0
* and errno set appropriately
*/
int
msdos_file_open(rtems_libio_t *iop, const char *pathname, uint32_t flag,
uint32_t mode)
{
ffc1ef18: 90 01 00 1c stw r0,28(r1)
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1ef1c: 38 a0 00 00 li r5,0
msdos_file_open(rtems_libio_t *iop, const char *pathname, uint32_t flag,
uint32_t mode)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
ffc1ef20: 81 23 00 2c lwz r9,44(r3)
* and errno set appropriately
*/
int
msdos_file_open(rtems_libio_t *iop, const char *pathname, uint32_t flag,
uint32_t mode)
{
ffc1ef24: 93 c1 00 10 stw r30,16(r1)
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
ffc1ef28: 83 c9 00 34 lwz r30,52(r9)
* and errno set appropriately
*/
int
msdos_file_open(rtems_libio_t *iop, const char *pathname, uint32_t flag,
uint32_t mode)
{
ffc1ef2c: 93 e1 00 14 stw r31,20(r1)
ffc1ef30: 7c 7f 1b 78 mr r31,r3
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1ef34: 80 7e 00 98 lwz r3,152(r30)
* and errno set appropriately
*/
int
msdos_file_open(rtems_libio_t *iop, const char *pathname, uint32_t flag,
uint32_t mode)
{
ffc1ef38: 93 a1 00 0c stw r29,12(r1)
ffc1ef3c: 93 81 00 08 stw r28,8(r1)
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
ffc1ef40: 83 bf 00 1c lwz r29,28(r31)
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1ef44: 4b fe e8 49 bl ffc0d78c <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1ef48: 2f 83 00 00 cmpwi cr7,r3,0
ffc1ef4c: 40 9e 00 68 bne- cr7,ffc1efb4 <msdos_file_open+0xa8> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one(EIO);
rc = fat_file_reopen(fat_fd);
ffc1ef50: 7f a3 eb 78 mr r3,r29
ffc1ef54: 4b ff 85 4d bl ffc174a0 <fat_file_reopen>
if (rc != RC_OK)
ffc1ef58: 7c 7c 1b 79 mr. r28,r3
ffc1ef5c: 40 82 00 20 bne- ffc1ef7c <msdos_file_open+0x70> <== NEVER TAKEN
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
ffc1ef60: 80 1f 00 18 lwz r0,24(r31)
ffc1ef64: 70 09 02 00 andi. r9,r0,512
iop->offset = fat_fd->fat_file_size;
ffc1ef68: 80 1d 00 18 lwz r0,24(r29)
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
ffc1ef6c: 40 82 00 3c bne- ffc1efa8 <msdos_file_open+0x9c>
iop->offset = fat_fd->fat_file_size;
iop->size = fat_fd->fat_file_size;
ffc1ef70: 90 1f 00 0c stw r0,12(r31)
ffc1ef74: 38 00 00 00 li r0,0
ffc1ef78: 90 1f 00 08 stw r0,8(r31)
rtems_semaphore_release(fs_info->vol_sema);
ffc1ef7c: 80 7e 00 98 lwz r3,152(r30)
ffc1ef80: 4b fe e9 99 bl ffc0d918 <rtems_semaphore_release>
return RC_OK;
}
ffc1ef84: 80 01 00 1c lwz r0,28(r1)
ffc1ef88: 7f 83 e3 78 mr r3,r28
ffc1ef8c: 83 a1 00 0c lwz r29,12(r1)
ffc1ef90: 7c 08 03 a6 mtlr r0
ffc1ef94: 83 81 00 08 lwz r28,8(r1)
ffc1ef98: 83 c1 00 10 lwz r30,16(r1)
ffc1ef9c: 83 e1 00 14 lwz r31,20(r1)
ffc1efa0: 38 21 00 18 addi r1,r1,24
ffc1efa4: 4e 80 00 20 blr
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
iop->offset = fat_fd->fat_file_size;
ffc1efa8: 93 9f 00 10 stw r28,16(r31)
ffc1efac: 90 1f 00 14 stw r0,20(r31)
ffc1efb0: 4b ff ff c0 b ffc1ef70 <msdos_file_open+0x64>
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
ffc1efb4: 48 00 52 5d bl ffc24210 <__errno> <== NOT EXECUTED
ffc1efb8: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1efbc: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1efc0: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
ffc1efc4: 4b ff ff c0 b ffc1ef84 <msdos_file_open+0x78> <== NOT EXECUTED
ffc1f0a8 <msdos_file_read>:
* the number of bytes read on success, or -1 if error occured (errno set
* appropriately)
*/
ssize_t
msdos_file_read(rtems_libio_t *iop, void *buffer, size_t count)
{
ffc1f0a8: 94 21 ff e0 stwu r1,-32(r1)
ffc1f0ac: 7c 08 02 a6 mflr r0
ffc1f0b0: 90 01 00 24 stw r0,36(r1)
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
ffc1f0b4: 81 23 00 2c lwz r9,44(r3)
* the number of bytes read on success, or -1 if error occured (errno set
* appropriately)
*/
ssize_t
msdos_file_read(rtems_libio_t *iop, void *buffer, size_t count)
{
ffc1f0b8: 93 e1 00 1c stw r31,28(r1)
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
ffc1f0bc: 83 e9 00 34 lwz r31,52(r9)
* the number of bytes read on success, or -1 if error occured (errno set
* appropriately)
*/
ssize_t
msdos_file_read(rtems_libio_t *iop, void *buffer, size_t count)
{
ffc1f0c0: 93 a1 00 14 stw r29,20(r1)
ffc1f0c4: 7c 7d 1b 78 mr r29,r3
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f0c8: 80 7f 00 98 lwz r3,152(r31)
* the number of bytes read on success, or -1 if error occured (errno set
* appropriately)
*/
ssize_t
msdos_file_read(rtems_libio_t *iop, void *buffer, size_t count)
{
ffc1f0cc: 93 81 00 10 stw r28,16(r1)
ffc1f0d0: 7c bc 2b 78 mr r28,r5
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f0d4: 38 a0 00 00 li r5,0
* the number of bytes read on success, or -1 if error occured (errno set
* appropriately)
*/
ssize_t
msdos_file_read(rtems_libio_t *iop, void *buffer, size_t count)
{
ffc1f0d8: 93 c1 00 18 stw r30,24(r1)
ffc1f0dc: 7c 9e 23 78 mr r30,r4
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f0e0: 38 80 00 00 li r4,0
* the number of bytes read on success, or -1 if error occured (errno set
* appropriately)
*/
ssize_t
msdos_file_read(rtems_libio_t *iop, void *buffer, size_t count)
{
ffc1f0e4: 93 61 00 0c stw r27,12(r1)
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
ffc1f0e8: 83 7d 00 1c lwz r27,28(r29)
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f0ec: 4b fe e6 a1 bl ffc0d78c <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1f0f0: 2f 83 00 00 cmpwi cr7,r3,0
ffc1f0f4: 40 9e 00 50 bne- cr7,ffc1f144 <msdos_file_read+0x9c> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one(EIO);
ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, iop->offset, count,
ffc1f0f8: 80 7d 00 2c lwz r3,44(r29)
ffc1f0fc: 7f c7 f3 78 mr r7,r30
ffc1f100: 80 bd 00 14 lwz r5,20(r29)
ffc1f104: 7f 64 db 78 mr r4,r27
ffc1f108: 7f 86 e3 78 mr r6,r28
ffc1f10c: 4b ff 83 ad bl ffc174b8 <fat_file_read>
ffc1f110: 7c 7e 1b 78 mr r30,r3
buffer);
rtems_semaphore_release(fs_info->vol_sema);
ffc1f114: 80 7f 00 98 lwz r3,152(r31)
ffc1f118: 4b fe e8 01 bl ffc0d918 <rtems_semaphore_release>
return ret;
}
ffc1f11c: 80 01 00 24 lwz r0,36(r1)
ffc1f120: 7f c3 f3 78 mr r3,r30
ffc1f124: 83 61 00 0c lwz r27,12(r1)
ffc1f128: 7c 08 03 a6 mtlr r0
ffc1f12c: 83 81 00 10 lwz r28,16(r1)
ffc1f130: 83 a1 00 14 lwz r29,20(r1)
ffc1f134: 83 c1 00 18 lwz r30,24(r1)
ffc1f138: 83 e1 00 1c lwz r31,28(r1)
ffc1f13c: 38 21 00 20 addi r1,r1,32
ffc1f140: 4e 80 00 20 blr
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
ffc1f144: 48 00 50 cd bl ffc24210 <__errno> <== NOT EXECUTED
ffc1f148: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1f14c: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1f150: 3b c0 ff ff li r30,-1 <== NOT EXECUTED
ffc1f154: 4b ff ff c8 b ffc1f11c <msdos_file_read+0x74> <== NOT EXECUTED
ffc1f740 <msdos_file_rmnod>:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_rmnod(rtems_filesystem_location_info_t *parent_pathloc,
rtems_filesystem_location_info_t *pathloc)
{
ffc1f740: 94 21 ff e8 stwu r1,-24(r1) <== NOT EXECUTED
ffc1f744: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = pathloc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f748: 38 a0 00 00 li r5,0 <== NOT EXECUTED
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_rmnod(rtems_filesystem_location_info_t *parent_pathloc,
rtems_filesystem_location_info_t *pathloc)
{
ffc1f74c: 90 01 00 1c stw r0,28(r1) <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
ffc1f750: 81 24 00 10 lwz r9,16(r4) <== NOT EXECUTED
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_rmnod(rtems_filesystem_location_info_t *parent_pathloc,
rtems_filesystem_location_info_t *pathloc)
{
ffc1f754: 93 c1 00 10 stw r30,16(r1) <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
ffc1f758: 83 c9 00 34 lwz r30,52(r9) <== NOT EXECUTED
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_rmnod(rtems_filesystem_location_info_t *parent_pathloc,
rtems_filesystem_location_info_t *pathloc)
{
ffc1f75c: 93 e1 00 14 stw r31,20(r1) <== NOT EXECUTED
ffc1f760: 7c 9f 23 78 mr r31,r4 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = pathloc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f764: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc1f768: 80 7e 00 98 lwz r3,152(r30) <== NOT EXECUTED
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_rmnod(rtems_filesystem_location_info_t *parent_pathloc,
rtems_filesystem_location_info_t *pathloc)
{
ffc1f76c: 93 a1 00 0c stw r29,12(r1) <== NOT EXECUTED
ffc1f770: 93 81 00 08 stw r28,8(r1) <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = pathloc->node_access;
ffc1f774: 83 bf 00 00 lwz r29,0(r31) <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f778: 4b fe e0 15 bl ffc0d78c <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1f77c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1f780: 40 9e 00 54 bne- cr7,ffc1f7d4 <msdos_file_rmnod+0x94> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
/* mark file removed */
rc = msdos_set_first_char4file_name(pathloc->mt_entry,
ffc1f784: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc1f788: 38 9d 00 20 addi r4,r29,32 <== NOT EXECUTED
ffc1f78c: 38 a0 00 e5 li r5,229 <== NOT EXECUTED
ffc1f790: 48 00 08 99 bl ffc20028 <msdos_set_first_char4file_name><== NOT EXECUTED
&fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
ffc1f794: 7c 7c 1b 79 mr. r28,r3 <== NOT EXECUTED
ffc1f798: 40 82 00 10 bne- ffc1f7a8 <msdos_file_rmnod+0x68> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
fat_file_mark_removed(pathloc->mt_entry, fat_fd);
ffc1f79c: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc1f7a0: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc1f7a4: 4b ff 87 c5 bl ffc17f68 <fat_file_mark_removed> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
ffc1f7a8: 80 7e 00 98 lwz r3,152(r30) <== NOT EXECUTED
ffc1f7ac: 4b fe e1 6d bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
return RC_OK;
}
ffc1f7b0: 80 01 00 1c lwz r0,28(r1) <== NOT EXECUTED
ffc1f7b4: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc1f7b8: 83 a1 00 0c lwz r29,12(r1) <== NOT EXECUTED
ffc1f7bc: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc1f7c0: 83 81 00 08 lwz r28,8(r1) <== NOT EXECUTED
ffc1f7c4: 83 c1 00 10 lwz r30,16(r1) <== NOT EXECUTED
ffc1f7c8: 83 e1 00 14 lwz r31,20(r1) <== NOT EXECUTED
ffc1f7cc: 38 21 00 18 addi r1,r1,24 <== NOT EXECUTED
ffc1f7d0: 4e 80 00 20 blr <== NOT EXECUTED
fat_file_fd_t *fat_fd = pathloc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
ffc1f7d4: 48 00 4a 3d bl ffc24210 <__errno> <== NOT EXECUTED
ffc1f7d8: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1f7dc: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1f7e0: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
ffc1f7e4: 4b ff ff cc b ffc1f7b0 <msdos_file_rmnod+0x70> <== NOT EXECUTED
ffc1f37c <msdos_file_stat>:
int
msdos_file_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
ffc1f37c: 94 21 ff e8 stwu r1,-24(r1)
ffc1f380: 7c 08 02 a6 mflr r0
ffc1f384: 7c 69 1b 78 mr r9,r3
ffc1f388: 90 01 00 1c stw r0,28(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = loc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f38c: 38 a0 00 00 li r5,0
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
ffc1f390: 81 63 00 10 lwz r11,16(r3)
int
msdos_file_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
ffc1f394: 93 c1 00 10 stw r30,16(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
ffc1f398: 83 cb 00 34 lwz r30,52(r11)
int
msdos_file_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
ffc1f39c: 93 e1 00 14 stw r31,20(r1)
ffc1f3a0: 7c 9f 23 78 mr r31,r4
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = loc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f3a4: 38 80 00 00 li r4,0
ffc1f3a8: 80 7e 00 98 lwz r3,152(r30)
int
msdos_file_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
ffc1f3ac: 93 a1 00 0c stw r29,12(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = loc->node_access;
ffc1f3b0: 83 a9 00 00 lwz r29,0(r9)
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f3b4: 4b fe e3 d9 bl ffc0d78c <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1f3b8: 2c 03 00 00 cmpwi r3,0
ffc1f3bc: 40 82 00 84 bne- ffc1f440 <msdos_file_stat+0xc4> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = fs_info->fat.vol.dev;
ffc1f3c0: 81 7e 00 5c lwz r11,92(r30)
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
ffc1f3c4: 80 1d 00 18 lwz r0,24(r29)
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = fs_info->fat.vol.dev;
ffc1f3c8: 81 5e 00 58 lwz r10,88(r30)
buf->st_ino = fat_fd->ino;
ffc1f3cc: 80 dd 00 0c lwz r6,12(r29)
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
ffc1f3d0: 54 07 ba 7e rlwinm r7,r0,23,9,31
buf->st_blksize = fs_info->fat.vol.bps;
ffc1f3d4: a1 1e 00 00 lhz r8,0(r30)
buf->st_mtime = fat_fd->mtime;
ffc1f3d8: 81 3d 00 40 lwz r9,64(r29)
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = fs_info->fat.vol.dev;
ffc1f3dc: 91 7f 00 04 stw r11,4(r31)
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
ffc1f3e0: 39 60 00 00 li r11,0
ffc1f3e4: 61 6b 81 ff ori r11,r11,33279
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = fs_info->fat.vol.dev;
ffc1f3e8: 91 5f 00 00 stw r10,0(r31)
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
ffc1f3ec: 39 40 00 00 li r10,0
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = fs_info->fat.vol.dev;
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
ffc1f3f0: 91 7f 00 0c stw r11,12(r31)
buf->st_rdev = 0ll;
ffc1f3f4: 39 60 00 00 li r11,0
buf->st_size = fat_fd->fat_file_size;
ffc1f3f8: 90 7f 00 20 stw r3,32(r31)
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = fs_info->fat.vol.dev;
buf->st_ino = fat_fd->ino;
ffc1f3fc: 90 df 00 08 stw r6,8(r31)
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
ffc1f400: 91 5f 00 18 stw r10,24(r31)
ffc1f404: 91 7f 00 1c stw r11,28(r31)
buf->st_size = fat_fd->fat_file_size;
ffc1f408: 90 1f 00 24 stw r0,36(r31)
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
ffc1f40c: 90 ff 00 44 stw r7,68(r31)
buf->st_blksize = fs_info->fat.vol.bps;
ffc1f410: 91 1f 00 40 stw r8,64(r31)
buf->st_mtime = fat_fd->mtime;
ffc1f414: 91 3f 00 30 stw r9,48(r31)
rtems_semaphore_release(fs_info->vol_sema);
ffc1f418: 80 7e 00 98 lwz r3,152(r30)
ffc1f41c: 4b fe e4 fd bl ffc0d918 <rtems_semaphore_release>
return RC_OK;
ffc1f420: 38 60 00 00 li r3,0
}
ffc1f424: 80 01 00 1c lwz r0,28(r1)
ffc1f428: 83 a1 00 0c lwz r29,12(r1)
ffc1f42c: 7c 08 03 a6 mtlr r0
ffc1f430: 83 c1 00 10 lwz r30,16(r1)
ffc1f434: 83 e1 00 14 lwz r31,20(r1)
ffc1f438: 38 21 00 18 addi r1,r1,24
ffc1f43c: 4e 80 00 20 blr
fat_file_fd_t *fat_fd = loc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
ffc1f440: 48 00 4d d1 bl ffc24210 <__errno> <== NOT EXECUTED
ffc1f444: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1f448: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1f44c: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc1f450: 4b ff ff d4 b ffc1f424 <msdos_file_stat+0xa8> <== NOT EXECUTED
ffc1f57c <msdos_file_sync>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_sync(rtems_libio_t *iop)
{
ffc1f57c: 94 21 ff e0 stwu r1,-32(r1) <== NOT EXECUTED
ffc1f580: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f584: 38 80 00 00 li r4,0 <== NOT EXECUTED
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_sync(rtems_libio_t *iop)
{
ffc1f588: 90 01 00 24 stw r0,36(r1) <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f58c: 38 a0 00 00 li r5,0 <== NOT EXECUTED
msdos_file_sync(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
ffc1f590: 81 23 00 2c lwz r9,44(r3) <== NOT EXECUTED
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_sync(rtems_libio_t *iop)
{
ffc1f594: 93 a1 00 14 stw r29,20(r1) <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
ffc1f598: 83 a9 00 34 lwz r29,52(r9) <== NOT EXECUTED
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_sync(rtems_libio_t *iop)
{
ffc1f59c: 93 e1 00 1c stw r31,28(r1) <== NOT EXECUTED
ffc1f5a0: 7c 7f 1b 78 mr r31,r3 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f5a4: 80 7d 00 98 lwz r3,152(r29) <== NOT EXECUTED
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_sync(rtems_libio_t *iop)
{
ffc1f5a8: 93 c1 00 18 stw r30,24(r1) <== NOT EXECUTED
ffc1f5ac: 93 61 00 0c stw r27,12(r1) <== NOT EXECUTED
ffc1f5b0: 93 81 00 10 stw r28,16(r1) <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
ffc1f5b4: 83 df 00 1c lwz r30,28(r31) <== NOT EXECUTED
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f5b8: 4b fe e1 d5 bl ffc0d78c <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1f5bc: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1f5c0: 40 9e 00 d4 bne- cr7,ffc1f694 <msdos_file_sync+0x118> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
/* synchronize file data */
rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);
ffc1f5c4: 80 7f 00 2c lwz r3,44(r31) <== NOT EXECUTED
ffc1f5c8: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc1f5cc: 4b ff 8a 65 bl ffc18030 <fat_file_datasync> <== NOT EXECUTED
if (rc != RC_OK)
ffc1f5d0: 7c 7c 1b 79 mr. r28,r3 <== NOT EXECUTED
ffc1f5d4: 40 82 00 10 bne- ffc1f5e4 <msdos_file_sync+0x68> <== NOT EXECUTED
/*
* if fat-file descriptor is not marked "removed" - synchronize file
* metadata
*/
if (!FAT_FILE_IS_REMOVED(fat_fd))
ffc1f5d8: 88 1e 00 30 lbz r0,48(r30) <== NOT EXECUTED
ffc1f5dc: 70 09 00 01 andi. r9,r0,1 <== NOT EXECUTED
ffc1f5e0: 41 82 00 34 beq- ffc1f614 <msdos_file_sync+0x98> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
rtems_semaphore_release(fs_info->vol_sema);
ffc1f5e4: 80 7d 00 98 lwz r3,152(r29) <== NOT EXECUTED
ffc1f5e8: 4b fe e3 31 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
return RC_OK;
}
ffc1f5ec: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
ffc1f5f0: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc1f5f4: 83 61 00 0c lwz r27,12(r1) <== NOT EXECUTED
ffc1f5f8: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc1f5fc: 83 81 00 10 lwz r28,16(r1) <== NOT EXECUTED
ffc1f600: 83 a1 00 14 lwz r29,20(r1) <== NOT EXECUTED
ffc1f604: 83 c1 00 18 lwz r30,24(r1) <== NOT EXECUTED
ffc1f608: 83 e1 00 1c lwz r31,28(r1) <== NOT EXECUTED
ffc1f60c: 38 21 00 20 addi r1,r1,32 <== NOT EXECUTED
ffc1f610: 4e 80 00 20 blr <== NOT EXECUTED
* if fat-file descriptor is not marked "removed" - synchronize file
* metadata
*/
if (!FAT_FILE_IS_REMOVED(fat_fd))
{
rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
ffc1f614: 80 7f 00 2c lwz r3,44(r31) <== NOT EXECUTED
ffc1f618: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc1f61c: 48 00 08 55 bl ffc1fe70 <msdos_set_first_cluster_num> <== NOT EXECUTED
if (rc != RC_OK)
ffc1f620: 7c 7b 1b 79 mr. r27,r3 <== NOT EXECUTED
ffc1f624: 40 82 00 3c bne- ffc1f660 <msdos_file_sync+0xe4> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
ffc1f628: 80 7f 00 2c lwz r3,44(r31) <== NOT EXECUTED
ffc1f62c: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc1f630: 48 00 09 59 bl ffc1ff88 <msdos_set_file_size> <== NOT EXECUTED
if (rc != RC_OK)
ffc1f634: 7c 7b 1b 79 mr. r27,r3 <== NOT EXECUTED
ffc1f638: 40 82 00 28 bne- ffc1f660 <msdos_file_sync+0xe4> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
ffc1f63c: 80 7f 00 2c lwz r3,44(r31) <== NOT EXECUTED
ffc1f640: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc1f644: 48 00 06 e5 bl ffc1fd28 <msdos_set_dir_wrt_time_and_date><== NOT EXECUTED
if (rc != RC_OK)
ffc1f648: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc1f64c: 41 82 ff 98 beq+ ffc1f5e4 <msdos_file_sync+0x68> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
ffc1f650: 80 7d 00 98 lwz r3,152(r29) <== NOT EXECUTED
return rc;
ffc1f654: 7f fc fb 78 mr r28,r31 <== NOT EXECUTED
return rc;
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
if (rc != RC_OK)
{
rtems_semaphore_release(fs_info->vol_sema);
ffc1f658: 4b fe e2 c1 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
return rc;
ffc1f65c: 4b ff ff 90 b ffc1f5ec <msdos_file_sync+0x70> <== NOT EXECUTED
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
if (rc != RC_OK)
{
rtems_semaphore_release(fs_info->vol_sema);
ffc1f660: 80 7d 00 98 lwz r3,152(r29) <== NOT EXECUTED
return rc;
ffc1f664: 7f 7c db 78 mr r28,r27 <== NOT EXECUTED
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
if (rc != RC_OK)
{
rtems_semaphore_release(fs_info->vol_sema);
ffc1f668: 4b fe e2 b1 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
}
}
rtems_semaphore_release(fs_info->vol_sema);
return RC_OK;
}
ffc1f66c: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
ffc1f670: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc1f674: 83 61 00 0c lwz r27,12(r1) <== NOT EXECUTED
ffc1f678: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc1f67c: 83 81 00 10 lwz r28,16(r1) <== NOT EXECUTED
ffc1f680: 83 a1 00 14 lwz r29,20(r1) <== NOT EXECUTED
ffc1f684: 83 c1 00 18 lwz r30,24(r1) <== NOT EXECUTED
ffc1f688: 83 e1 00 1c lwz r31,28(r1) <== NOT EXECUTED
ffc1f68c: 38 21 00 20 addi r1,r1,32 <== NOT EXECUTED
ffc1f690: 4e 80 00 20 blr <== NOT EXECUTED
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
ffc1f694: 48 00 4b 7d bl ffc24210 <__errno> <== NOT EXECUTED
ffc1f698: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1f69c: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1f6a0: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
ffc1f6a4: 4b ff ff 48 b ffc1f5ec <msdos_file_sync+0x70> <== NOT EXECUTED
ffc1f158 <msdos_file_write>:
* the number of bytes written on success, or -1 if error occured
* and errno set appropriately
*/
ssize_t
msdos_file_write(rtems_libio_t *iop,const void *buffer, size_t count)
{
ffc1f158: 94 21 ff e0 stwu r1,-32(r1)
ffc1f15c: 7c 08 02 a6 mflr r0
ffc1f160: 90 01 00 24 stw r0,36(r1)
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
ffc1f164: 81 23 00 2c lwz r9,44(r3)
* the number of bytes written on success, or -1 if error occured
* and errno set appropriately
*/
ssize_t
msdos_file_write(rtems_libio_t *iop,const void *buffer, size_t count)
{
ffc1f168: 93 a1 00 14 stw r29,20(r1)
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
ffc1f16c: 83 a9 00 34 lwz r29,52(r9)
* the number of bytes written on success, or -1 if error occured
* and errno set appropriately
*/
ssize_t
msdos_file_write(rtems_libio_t *iop,const void *buffer, size_t count)
{
ffc1f170: 93 e1 00 1c stw r31,28(r1)
ffc1f174: 7c 7f 1b 78 mr r31,r3
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f178: 80 7d 00 98 lwz r3,152(r29)
* the number of bytes written on success, or -1 if error occured
* and errno set appropriately
*/
ssize_t
msdos_file_write(rtems_libio_t *iop,const void *buffer, size_t count)
{
ffc1f17c: 93 61 00 0c stw r27,12(r1)
ffc1f180: 7c bb 2b 78 mr r27,r5
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f184: 38 a0 00 00 li r5,0
* the number of bytes written on success, or -1 if error occured
* and errno set appropriately
*/
ssize_t
msdos_file_write(rtems_libio_t *iop,const void *buffer, size_t count)
{
ffc1f188: 93 81 00 10 stw r28,16(r1)
ffc1f18c: 7c 9c 23 78 mr r28,r4
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f190: 38 80 00 00 li r4,0
* the number of bytes written on success, or -1 if error occured
* and errno set appropriately
*/
ssize_t
msdos_file_write(rtems_libio_t *iop,const void *buffer, size_t count)
{
ffc1f194: 93 c1 00 18 stw r30,24(r1)
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
ffc1f198: 83 df 00 1c lwz r30,28(r31)
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f19c: 4b fe e5 f1 bl ffc0d78c <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1f1a0: 2f 83 00 00 cmpwi cr7,r3,0
ffc1f1a4: 40 9e 00 a0 bne- cr7,ffc1f244 <msdos_file_write+0xec> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one(EIO);
ret = fat_file_write(iop->pathinfo.mt_entry, fat_fd, iop->offset, count,
ffc1f1a8: 80 7f 00 2c lwz r3,44(r31)
ffc1f1ac: 7f 87 e3 78 mr r7,r28
ffc1f1b0: 80 bf 00 14 lwz r5,20(r31)
ffc1f1b4: 7f c4 f3 78 mr r4,r30
ffc1f1b8: 7f 66 db 78 mr r6,r27
ffc1f1bc: 4b ff 8b 05 bl ffc17cc0 <fat_file_write>
buffer);
if (ret < 0)
ffc1f1c0: 7c 7c 1b 79 mr. r28,r3
ffc1f1c4: 41 80 00 94 blt- ffc1f258 <msdos_file_write+0x100> <== NEVER TAKEN
/*
* update file size in both fat-file descriptor and file control block if
* file was extended
*/
if (iop->offset + ret > fat_fd->fat_file_size)
ffc1f1c8: 81 1f 00 10 lwz r8,16(r31)
ffc1f1cc: 7f 8b e3 78 mr r11,r28
ffc1f1d0: 81 3f 00 14 lwz r9,20(r31)
ffc1f1d4: 7f 8a fe 70 srawi r10,r28,31
ffc1f1d8: 80 1e 00 18 lwz r0,24(r30)
ffc1f1dc: 38 e0 00 00 li r7,0
ffc1f1e0: 7d 6b 48 14 addc r11,r11,r9
ffc1f1e4: 7d 4a 41 14 adde r10,r10,r8
ffc1f1e8: 2f 8a 00 00 cmpwi cr7,r10,0
ffc1f1ec: 40 9d 00 48 ble- cr7,ffc1f234 <msdos_file_write+0xdc> <== ALWAYS TAKEN
fat_fd->fat_file_size = iop->offset + ret;
ffc1f1f0: 7c 1c 4a 14 add r0,r28,r9
ffc1f1f4: 90 1e 00 18 stw r0,24(r30)
ffc1f1f8: 38 e0 00 00 li r7,0
iop->size = fat_fd->fat_file_size;
ffc1f1fc: 90 ff 00 08 stw r7,8(r31)
ffc1f200: 90 1f 00 0c stw r0,12(r31)
rtems_semaphore_release(fs_info->vol_sema);
ffc1f204: 80 7d 00 98 lwz r3,152(r29)
ffc1f208: 4b fe e7 11 bl ffc0d918 <rtems_semaphore_release>
return ret;
}
ffc1f20c: 80 01 00 24 lwz r0,36(r1)
ffc1f210: 7f 83 e3 78 mr r3,r28
ffc1f214: 83 61 00 0c lwz r27,12(r1)
ffc1f218: 7c 08 03 a6 mtlr r0
ffc1f21c: 83 81 00 10 lwz r28,16(r1)
ffc1f220: 83 a1 00 14 lwz r29,20(r1)
ffc1f224: 83 c1 00 18 lwz r30,24(r1)
ffc1f228: 83 e1 00 1c lwz r31,28(r1)
ffc1f22c: 38 21 00 20 addi r1,r1,32
ffc1f230: 4e 80 00 20 blr
/*
* update file size in both fat-file descriptor and file control block if
* file was extended
*/
if (iop->offset + ret > fat_fd->fat_file_size)
ffc1f234: 40 be ff c8 bne- cr7,ffc1f1fc <msdos_file_write+0xa4> <== NEVER TAKEN
ffc1f238: 7f 8b 00 40 cmplw cr7,r11,r0
ffc1f23c: 40 bd ff c0 ble- cr7,ffc1f1fc <msdos_file_write+0xa4>
ffc1f240: 4b ff ff b0 b ffc1f1f0 <msdos_file_write+0x98>
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
ffc1f244: 48 00 4f cd bl ffc24210 <__errno> <== NOT EXECUTED
ffc1f248: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1f24c: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1f250: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
ffc1f254: 4b ff ff b8 b ffc1f20c <msdos_file_write+0xb4> <== NOT EXECUTED
ret = fat_file_write(iop->pathinfo.mt_entry, fat_fd, iop->offset, count,
buffer);
if (ret < 0)
{
rtems_semaphore_release(fs_info->vol_sema);
ffc1f258: 80 7d 00 98 lwz r3,152(r29) <== NOT EXECUTED
return -1;
ffc1f25c: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
ret = fat_file_write(iop->pathinfo.mt_entry, fat_fd, iop->offset, count,
buffer);
if (ret < 0)
{
rtems_semaphore_release(fs_info->vol_sema);
ffc1f260: 4b fe e6 b9 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
return -1;
ffc1f264: 4b ff ff a8 b ffc1f20c <msdos_file_write+0xb4> <== NOT EXECUTED
ffc23534 <msdos_filename_unix2dos>:
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
dn[i] = ' ';
ffc23534: 39 60 00 0b li r11,11
ffc23538: 7d 69 03 a6 mtctr r11
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
ffc2353c: 39 20 00 00 li r9,0
dn[i] = ' ';
ffc23540: 38 00 00 20 li r0,32
ffc23544: 7c 05 49 ae stbx r0,r5,r9
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
ffc23548: 39 29 00 01 addi r9,r9,1
ffc2354c: 42 00 ff f8 bdnz+ ffc23544 <msdos_filename_unix2dos+0x10>
/*
* The filenames "." and ".." are handled specially, since they
* don't follow dos filename rules.
*/
if (un[0] == '.' && unlen == 1) {
ffc23550: 88 03 00 00 lbz r0,0(r3)
ffc23554: 2f 80 00 2e cmpwi cr7,r0,46
ffc23558: 41 9e 01 80 beq- cr7,ffc236d8 <msdos_filename_unix2dos+0x1a4><== NEVER TAKEN
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
ffc2355c: 2f 04 00 00 cmpwi cr6,r4,0
ffc23560: 41 9a 00 2c beq- cr6,ffc2358c <msdos_filename_unix2dos+0x58><== NEVER TAKEN
ffc23564: 40 9e 00 30 bne- cr7,ffc23594 <msdos_filename_unix2dos+0x60><== ALWAYS TAKEN
return 0;
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
dn[0] = '.';
dn[1] = '.';
return 0;
ffc23568: 7c 69 1b 78 mr r9,r3 <== NOT EXECUTED
ffc2356c: 7c 89 03 a6 mtctr r4 <== NOT EXECUTED
ffc23570: 48 00 00 14 b ffc23584 <msdos_filename_unix2dos+0x50><== NOT EXECUTED
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
ffc23574: 8c 09 00 01 lbzu r0,1(r9) <== NOT EXECUTED
un++;
ffc23578: 38 63 00 01 addi r3,r3,1 <== NOT EXECUTED
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
ffc2357c: 2f 80 00 2e cmpwi cr7,r0,46 <== NOT EXECUTED
ffc23580: 40 9e 00 14 bne- cr7,ffc23594 <msdos_filename_unix2dos+0x60><== NOT EXECUTED
un++;
unlen--;
ffc23584: 38 84 ff ff addi r4,r4,-1 <== NOT EXECUTED
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
ffc23588: 42 00 ff ec bdnz+ ffc23574 <msdos_filename_unix2dos+0x40><== NOT EXECUTED
dn[i] = msdos_map[c];
un++;
unlen--;
}
return 0;
}
ffc2358c: 38 60 00 00 li r3,0
ffc23590: 4e 80 00 20 blr
* Copy the unix filename into the dos filename string upto the end
* of string, a '.', or 8 characters. Whichever happens first stops
* us. This forms the name portion of the dos filename. Fold to
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
ffc23594: 2f 80 00 00 cmpwi cr7,r0,0
ffc23598: 41 9e 01 68 beq- cr7,ffc23700 <msdos_filename_unix2dos+0x1cc><== NEVER TAKEN
if (msdos_map[c] == 0)
ffc2359c: 3d 00 ff c3 lis r8,-61
ffc235a0: 39 08 56 14 addi r8,r8,22036
ffc235a4: 7d 28 00 ae lbzx r9,r8,r0
ffc235a8: 2f 09 00 00 cmpwi cr6,r9,0
ffc235ac: 41 9a 01 54 beq- cr6,ffc23700 <msdos_filename_unix2dos+0x1cc><== NEVER TAKEN
break;
dn[i] = msdos_map[c];
un++;
unlen--;
ffc235b0: 38 84 ff ff addi r4,r4,-1
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
if (msdos_map[c] == 0)
break;
dn[i] = msdos_map[c];
ffc235b4: 99 25 00 00 stb r9,0(r5)
* Copy the unix filename into the dos filename string upto the end
* of string, a '.', or 8 characters. Whichever happens first stops
* us. This forms the name portion of the dos filename. Fold to
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
ffc235b8: 2f 84 00 00 cmpwi cr7,r4,0
if (msdos_map[c] == 0)
break;
dn[i] = msdos_map[c];
un++;
ffc235bc: 38 63 00 01 addi r3,r3,1
/*
* Convert a unix filename to a DOS filename. Return -1 if wrong name is
* supplied.
*/
int
msdos_filename_unix2dos(const char *un, int unlen, char *dn)
ffc235c0: 38 00 00 07 li r0,7
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
if (msdos_map[c] == 0)
break;
dn[i] = msdos_map[c];
un++;
unlen--;
ffc235c4: 7c aa 2b 78 mr r10,r5
/*
* Convert a unix filename to a DOS filename. Return -1 if wrong name is
* supplied.
*/
int
msdos_filename_unix2dos(const char *un, int unlen, char *dn)
ffc235c8: 7c 09 03 a6 mtctr r0
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
if (msdos_map[c] == 0)
break;
dn[i] = msdos_map[c];
un++;
ffc235cc: 39 23 00 01 addi r9,r3,1
* Copy the unix filename into the dos filename string upto the end
* of string, a '.', or 8 characters. Whichever happens first stops
* us. This forms the name portion of the dos filename. Fold to
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
ffc235d0: 41 be ff bc beq- cr7,ffc2358c <msdos_filename_unix2dos+0x58><== NEVER TAKEN
ffc235d4: 88 03 00 00 lbz r0,0(r3)
ffc235d8: 2f 80 00 00 cmpwi cr7,r0,0
ffc235dc: 2f 00 00 2e cmpwi cr6,r0,46
ffc235e0: 41 9e 01 20 beq- cr7,ffc23700 <msdos_filename_unix2dos+0x1cc><== NEVER TAKEN
ffc235e4: 41 9a 01 1c beq- cr6,ffc23700 <msdos_filename_unix2dos+0x1cc><== NEVER TAKEN
if (msdos_map[c] == 0)
ffc235e8: 7d 68 00 ae lbzx r11,r8,r0
ffc235ec: 2f 0b 00 00 cmpwi cr6,r11,0
ffc235f0: 41 9a 01 10 beq- cr6,ffc23700 <msdos_filename_unix2dos+0x1cc><== NEVER TAKEN
break;
dn[i] = msdos_map[c];
ffc235f4: 9d 6a 00 01 stbu r11,1(r10)
un++;
unlen--;
ffc235f8: 38 84 ff ff addi r4,r4,-1
* Copy the unix filename into the dos filename string upto the end
* of string, a '.', or 8 characters. Whichever happens first stops
* us. This forms the name portion of the dos filename. Fold to
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
ffc235fc: 42 40 00 18 bdz- ffc23614 <msdos_filename_unix2dos+0xe0>
ffc23600: 2f 84 00 00 cmpwi cr7,r4,0
if (msdos_map[c] == 0)
break;
dn[i] = msdos_map[c];
un++;
ffc23604: 7d 23 4b 78 mr r3,r9
ffc23608: 39 23 00 01 addi r9,r3,1
* Copy the unix filename into the dos filename string upto the end
* of string, a '.', or 8 characters. Whichever happens first stops
* us. This forms the name portion of the dos filename. Fold to
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
ffc2360c: 40 9e ff c8 bne+ cr7,ffc235d4 <msdos_filename_unix2dos+0xa0>
ffc23610: 4b ff ff 7c b ffc2358c <msdos_filename_unix2dos+0x58>
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
ffc23614: 2f 84 00 00 cmpwi cr7,r4,0
ffc23618: 41 be ff 74 beq- cr7,ffc2358c <msdos_filename_unix2dos+0x58><== NEVER TAKEN
ffc2361c: 88 03 00 01 lbz r0,1(r3)
ffc23620: 2f 80 00 00 cmpwi cr7,r0,0
ffc23624: 41 be ff 68 beq- cr7,ffc2358c <msdos_filename_unix2dos+0x58><== NEVER TAKEN
un++;
unlen--;
/* Make sure we've skipped over the dot before stopping. */
if (c == '.')
ffc23628: 2f 80 00 2e cmpwi cr7,r0,46
ffc2362c: 7c 89 03 a6 mtctr r4
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
un++;
ffc23630: 39 29 00 01 addi r9,r9,1
unlen--;
ffc23634: 39 64 ff ff addi r11,r4,-1
/* Make sure we've skipped over the dot before stopping. */
if (c == '.')
ffc23638: 41 9e 00 24 beq- cr7,ffc2365c <msdos_filename_unix2dos+0x128><== NEVER TAKEN
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
ffc2363c: 42 40 ff 50 bdz+ ffc2358c <msdos_filename_unix2dos+0x58>
ffc23640: 88 09 00 00 lbz r0,0(r9)
un++;
unlen--;
ffc23644: 39 6b ff ff addi r11,r11,-1
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
un++;
ffc23648: 39 29 00 01 addi r9,r9,1
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
ffc2364c: 2f 80 00 00 cmpwi cr7,r0,0
un++;
unlen--;
/* Make sure we've skipped over the dot before stopping. */
if (c == '.')
ffc23650: 2f 00 00 2e cmpwi cr6,r0,46
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
ffc23654: 41 be ff 38 beq- cr7,ffc2358c <msdos_filename_unix2dos+0x58><== NEVER TAKEN
un++;
unlen--;
/* Make sure we've skipped over the dot before stopping. */
if (c == '.')
ffc23658: 40 9a ff e4 bne+ cr6,ffc2363c <msdos_filename_unix2dos+0x108><== ALWAYS TAKEN
/*
* Copy in the extension part of the name, if any. Force to upper
* case. Note that the extension is allowed to contain '.'s.
* Filenames in this form are probably inaccessable under dos.
*/
for (i = 8; i <= 10 && unlen && (c = *un); i++) {
ffc2365c: 2f 8b 00 00 cmpwi cr7,r11,0 <== NOT EXECUTED
ffc23660: 41 be ff 2c beq- cr7,ffc2358c <msdos_filename_unix2dos+0x58><== NOT EXECUTED
ffc23664: 88 09 00 00 lbz r0,0(r9) <== NOT EXECUTED
ffc23668: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc2366c: 41 be ff 20 beq- cr7,ffc2358c <msdos_filename_unix2dos+0x58><== NOT EXECUTED
if (msdos_map[c] == 0)
ffc23670: 3d 40 ff c3 lis r10,-61 <== NOT EXECUTED
ffc23674: 39 4a 56 14 addi r10,r10,22036 <== NOT EXECUTED
ffc23678: 7c 0a 00 ae lbzx r0,r10,r0 <== NOT EXECUTED
ffc2367c: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc23680: 41 be ff 0c beq- cr7,ffc2358c <msdos_filename_unix2dos+0x58><== NOT EXECUTED
/*
* Copy in the extension part of the name, if any. Force to upper
* case. Note that the extension is allowed to contain '.'s.
* Filenames in this form are probably inaccessable under dos.
*/
for (i = 8; i <= 10 && unlen && (c = *un); i++) {
ffc23684: 2f 8b 00 01 cmpwi cr7,r11,1 <== NOT EXECUTED
if (msdos_map[c] == 0)
break;
dn[i] = msdos_map[c];
ffc23688: 98 05 00 08 stb r0,8(r5) <== NOT EXECUTED
/*
* Copy in the extension part of the name, if any. Force to upper
* case. Note that the extension is allowed to contain '.'s.
* Filenames in this form are probably inaccessable under dos.
*/
for (i = 8; i <= 10 && unlen && (c = *un); i++) {
ffc2368c: 41 be ff 00 beq- cr7,ffc2358c <msdos_filename_unix2dos+0x58><== NOT EXECUTED
ffc23690: 88 09 00 01 lbz r0,1(r9) <== NOT EXECUTED
ffc23694: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc23698: 41 be fe f4 beq- cr7,ffc2358c <msdos_filename_unix2dos+0x58><== NOT EXECUTED
if (msdos_map[c] == 0)
ffc2369c: 7c 0a 00 ae lbzx r0,r10,r0 <== NOT EXECUTED
ffc236a0: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc236a4: 41 be fe e8 beq- cr7,ffc2358c <msdos_filename_unix2dos+0x58><== NOT EXECUTED
/*
* Copy in the extension part of the name, if any. Force to upper
* case. Note that the extension is allowed to contain '.'s.
* Filenames in this form are probably inaccessable under dos.
*/
for (i = 8; i <= 10 && unlen && (c = *un); i++) {
ffc236a8: 2f 8b 00 02 cmpwi cr7,r11,2 <== NOT EXECUTED
if (msdos_map[c] == 0)
break;
dn[i] = msdos_map[c];
ffc236ac: 98 05 00 09 stb r0,9(r5) <== NOT EXECUTED
/*
* Copy in the extension part of the name, if any. Force to upper
* case. Note that the extension is allowed to contain '.'s.
* Filenames in this form are probably inaccessable under dos.
*/
for (i = 8; i <= 10 && unlen && (c = *un); i++) {
ffc236b0: 41 be fe dc beq- cr7,ffc2358c <msdos_filename_unix2dos+0x58><== NOT EXECUTED
ffc236b4: 88 09 00 02 lbz r0,2(r9) <== NOT EXECUTED
ffc236b8: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc236bc: 41 be fe d0 beq- cr7,ffc2358c <msdos_filename_unix2dos+0x58><== NOT EXECUTED
if (msdos_map[c] == 0)
ffc236c0: 7c 0a 00 ae lbzx r0,r10,r0 <== NOT EXECUTED
ffc236c4: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc236c8: 41 be fe c4 beq- cr7,ffc2358c <msdos_filename_unix2dos+0x58><== NOT EXECUTED
break;
dn[i] = msdos_map[c];
ffc236cc: 98 05 00 0a stb r0,10(r5) <== NOT EXECUTED
un++;
unlen--;
}
return 0;
}
ffc236d0: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc236d4: 4e 80 00 20 blr <== NOT EXECUTED
/*
* The filenames "." and ".." are handled specially, since they
* don't follow dos filename rules.
*/
if (un[0] == '.' && unlen == 1) {
ffc236d8: 2f 04 00 01 cmpwi cr6,r4,1 <== NOT EXECUTED
ffc236dc: 41 9a 00 2c beq- cr6,ffc23708 <msdos_filename_unix2dos+0x1d4><== NOT EXECUTED
dn[0] = '.';
return 0;
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
ffc236e0: 89 23 00 01 lbz r9,1(r3) <== NOT EXECUTED
ffc236e4: 2f 09 00 2e cmpwi cr6,r9,46 <== NOT EXECUTED
ffc236e8: 40 9a fe 74 bne+ cr6,ffc2355c <msdos_filename_unix2dos+0x28><== NOT EXECUTED
ffc236ec: 2f 04 00 02 cmpwi cr6,r4,2 <== NOT EXECUTED
ffc236f0: 40 9a fe 6c bne+ cr6,ffc2355c <msdos_filename_unix2dos+0x28><== NOT EXECUTED
dn[0] = '.';
ffc236f4: 99 25 00 00 stb r9,0(r5) <== NOT EXECUTED
dn[1] = '.';
ffc236f8: 99 25 00 01 stb r9,1(r5) <== NOT EXECUTED
return 0;
ffc236fc: 4b ff fe 90 b ffc2358c <msdos_filename_unix2dos+0x58><== NOT EXECUTED
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
if (msdos_map[c] == 0)
break;
dn[i] = msdos_map[c];
un++;
unlen--;
ffc23700: 7c 69 1b 78 mr r9,r3 <== NOT EXECUTED
ffc23704: 4b ff ff 20 b ffc23624 <msdos_filename_unix2dos+0xf0><== NOT EXECUTED
/*
* The filenames "." and ".." are handled specially, since they
* don't follow dos filename rules.
*/
if (un[0] == '.' && unlen == 1) {
dn[0] = '.';
ffc23708: 98 05 00 00 stb r0,0(r5) <== NOT EXECUTED
return 0;
ffc2370c: 4b ff fe 80 b ffc2358c <msdos_filename_unix2dos+0x58><== NOT EXECUTED
ffc214f4 <msdos_find_name>:
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
ffc214f4: 94 21 ff a8 stwu r1,-88(r1)
ffc214f8: 7c 08 02 a6 mflr r0
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
name_type = msdos_long_to_short (name,
ffc214fc: 38 c0 00 0b li r6,11
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
ffc21500: 90 01 00 5c stw r0,92(r1)
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
ffc21504: 38 00 00 00 li r0,0
const char *name,
int name_len
)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
ffc21508: 81 23 00 10 lwz r9,16(r3)
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
ffc2150c: 93 81 00 48 stw r28,72(r1)
ffc21510: 7c 9c 23 78 mr r28,r4
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
name_type = msdos_long_to_short (name,
ffc21514: 7c a4 2b 78 mr r4,r5
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
ffc21518: 93 a1 00 4c stw r29,76(r1)
ffc2151c: 7c bd 2b 78 mr r29,r5
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
name_type = msdos_long_to_short (name,
ffc21520: 38 a1 00 1c addi r5,r1,28
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
ffc21524: 93 e1 00 54 stw r31,84(r1)
ffc21528: 7c 7f 1b 78 mr r31,r3
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
name_type = msdos_long_to_short (name,
ffc2152c: 7f 83 e3 78 mr r3,r28
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
ffc21530: 93 c1 00 50 stw r30,80(r1)
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
ffc21534: 90 01 00 08 stw r0,8(r1)
const char *name,
int name_len
)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
ffc21538: 83 c9 00 34 lwz r30,52(r9)
fat_dir_pos_t dir_pos;
unsigned short time_val = 0;
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
ffc2153c: 90 01 00 1c stw r0,28(r1)
ffc21540: 90 01 00 20 stw r0,32(r1)
ffc21544: 90 01 00 24 stw r0,36(r1)
ffc21548: 90 01 00 28 stw r0,40(r1)
ffc2154c: 90 01 00 2c stw r0,44(r1)
ffc21550: 90 01 00 30 stw r0,48(r1)
ffc21554: 90 01 00 34 stw r0,52(r1)
ffc21558: 90 01 00 38 stw r0,56(r1)
name_type = msdos_long_to_short (name,
ffc2155c: 4b ff e4 1d bl ffc1f978 <msdos_long_to_short>
ffc21560: 7c 67 1b 78 mr r7,r3
/*
* find the node which correspondes to the name in the directory pointed by
* 'parent_loc'
*/
rc = msdos_get_name_node(parent_loc, false, name, name_len, name_type,
ffc21564: 7f a6 eb 78 mr r6,r29
ffc21568: 38 80 00 00 li r4,0
ffc2156c: 7f e3 fb 78 mr r3,r31
ffc21570: 7f 85 e3 78 mr r5,r28
ffc21574: 39 01 00 0c addi r8,r1,12
ffc21578: 39 21 00 1c addi r9,r1,28
ffc2157c: 4b ff fe 2d bl ffc213a8 <msdos_get_name_node>
&dir_pos, node_entry);
if (rc != RC_OK)
ffc21580: 7c 7d 1b 79 mr. r29,r3
ffc21584: 40 82 00 14 bne- ffc21598 <msdos_find_name+0xa4>
return rc;
if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) ||
ffc21588: 88 01 00 27 lbz r0,39(r1)
((*MSDOS_DIR_ATTR(node_entry) & MSDOS_ATTR_LFN_MASK) == MSDOS_ATTR_LFN))
return MSDOS_NAME_NOT_FOUND_ERR;
ffc2158c: 3b a0 7d 01 li r29,32001
rc = msdos_get_name_node(parent_loc, false, name, name_len, name_type,
&dir_pos, node_entry);
if (rc != RC_OK)
return rc;
if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) ||
ffc21590: 70 09 00 08 andi. r9,r0,8
ffc21594: 41 82 00 28 beq- ffc215bc <msdos_find_name+0xc8> <== ALWAYS TAKEN
/* update node_info_ptr field */
parent_loc->node_access = fat_fd;
return rc;
}
ffc21598: 80 01 00 5c lwz r0,92(r1)
ffc2159c: 7f a3 eb 78 mr r3,r29
ffc215a0: 83 81 00 48 lwz r28,72(r1)
ffc215a4: 7c 08 03 a6 mtlr r0
ffc215a8: 83 a1 00 4c lwz r29,76(r1)
ffc215ac: 83 c1 00 50 lwz r30,80(r1)
ffc215b0: 83 e1 00 54 lwz r31,84(r1)
ffc215b4: 38 21 00 58 addi r1,r1,88
ffc215b8: 4e 80 00 20 blr
&dir_pos, node_entry);
if (rc != RC_OK)
return rc;
if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) ||
((*MSDOS_DIR_ATTR(node_entry) & MSDOS_ATTR_LFN_MASK) == MSDOS_ATTR_LFN))
ffc215bc: 54 00 06 be clrlwi r0,r0,26
rc = msdos_get_name_node(parent_loc, false, name, name_len, name_type,
&dir_pos, node_entry);
if (rc != RC_OK)
return rc;
if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) ||
ffc215c0: 2f 80 00 0f cmpwi cr7,r0,15
ffc215c4: 41 9e ff d4 beq+ cr7,ffc21598 <msdos_find_name+0xa4> <== NEVER TAKEN
((*MSDOS_DIR_ATTR(node_entry) & MSDOS_ATTR_LFN_MASK) == MSDOS_ATTR_LFN))
return MSDOS_NAME_NOT_FOUND_ERR;
/* open fat-file corresponded to the found node */
rc = fat_file_open(parent_loc->mt_entry, &dir_pos, &fat_fd);
ffc215c8: 80 7f 00 10 lwz r3,16(r31)
ffc215cc: 38 81 00 0c addi r4,r1,12
ffc215d0: 38 a1 00 08 addi r5,r1,8
ffc215d4: 4b ff 5b c9 bl ffc1719c <fat_file_open>
if (rc != RC_OK)
ffc215d8: 7c 7d 1b 79 mr. r29,r3
ffc215dc: 40 a2 ff bc bne- ffc21598 <msdos_find_name+0xa4>
return rc;
fat_fd->dir_pos = dir_pos;
ffc215e0: 83 a1 00 08 lwz r29,8(r1)
ffc215e4: 80 01 00 0c lwz r0,12(r1)
* size and first cluster num to the disk after each write operation
* (even if one byte is written - that is TOO slow) because
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
ffc215e8: 83 9d 00 08 lwz r28,8(r29)
/* open fat-file corresponded to the found node */
rc = fat_file_open(parent_loc->mt_entry, &dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
fat_fd->dir_pos = dir_pos;
ffc215ec: 90 1d 00 20 stw r0,32(r29)
* size and first cluster num to the disk after each write operation
* (even if one byte is written - that is TOO slow) because
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
ffc215f0: 2f 9c 00 01 cmpwi cr7,r28,1
/* open fat-file corresponded to the found node */
rc = fat_file_open(parent_loc->mt_entry, &dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
fat_fd->dir_pos = dir_pos;
ffc215f4: 80 01 00 10 lwz r0,16(r1)
ffc215f8: 90 1d 00 24 stw r0,36(r29)
ffc215fc: 80 01 00 14 lwz r0,20(r1)
ffc21600: 90 1d 00 28 stw r0,40(r29)
ffc21604: 80 01 00 18 lwz r0,24(r1)
ffc21608: 90 1d 00 2c stw r0,44(r29)
* size and first cluster num to the disk after each write operation
* (even if one byte is written - that is TOO slow) because
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
ffc2160c: 41 9e 00 24 beq- cr7,ffc21630 <msdos_find_name+0x13c>
fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
}
}
/* close fat-file corresponded to the node we searched in */
rc = fat_file_close(parent_loc->mt_entry, parent_loc->node_access);
ffc21610: 80 7f 00 10 lwz r3,16(r31)
ffc21614: 80 9f 00 00 lwz r4,0(r31)
ffc21618: 4b ff 62 69 bl ffc17880 <fat_file_close>
if (rc != RC_OK)
ffc2161c: 7c 7d 1b 79 mr. r29,r3
ffc21620: 40 82 00 c8 bne- ffc216e8 <msdos_find_name+0x1f4> <== NEVER TAKEN
fat_file_close(parent_loc->mt_entry, fat_fd);
return rc;
}
/* update node_info_ptr field */
parent_loc->node_access = fat_fd;
ffc21624: 80 01 00 08 lwz r0,8(r1)
ffc21628: 90 1f 00 00 stw r0,0(r31)
return rc;
ffc2162c: 4b ff ff 6c b ffc21598 <msdos_find_name+0xa4>
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
{
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
ffc21630: a1 21 00 30 lhz r9,48(r1)
ffc21634: a0 01 00 36 lhz r0,54(r1)
ffc21638: 55 2a c2 3e rlwinm r10,r9,24,8,31
ffc2163c: 55 29 44 2e rlwinm r9,r9,8,16,23
ffc21640: 54 08 c2 3e rlwinm r8,r0,24,8,31
ffc21644: 7d 4a 4b 78 or r10,r10,r9
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
date = *MSDOS_DIR_WRITE_DATE(node_entry);
ffc21648: a1 21 00 34 lhz r9,52(r1)
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
{
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
ffc2164c: 54 0b 44 2e rlwinm r11,r0,8,16,23
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
ffc21650: a0 01 00 32 lhz r0,50(r1)
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
{
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
ffc21654: 55 4a 80 1e rlwinm r10,r10,16,0,15
ffc21658: 7d 0b 5b 78 or r11,r8,r11
ffc2165c: 7d 4b 5b 78 or r11,r10,r11
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
date = *MSDOS_DIR_WRITE_DATE(node_entry);
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
ffc21660: 55 23 c2 3e rlwinm r3,r9,24,8,31
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
{
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
ffc21664: 91 7d 00 1c stw r11,28(r29)
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
date = *MSDOS_DIR_WRITE_DATE(node_entry);
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
ffc21668: 55 29 44 2e rlwinm r9,r9,8,16,23
ffc2166c: 54 04 c2 3e rlwinm r4,r0,24,8,31
ffc21670: 54 00 44 2e rlwinm r0,r0,8,16,23
ffc21674: 7c 63 4b 78 or r3,r3,r9
ffc21678: 7c 84 03 78 or r4,r4,r0
ffc2167c: 48 00 1d b1 bl ffc2342c <msdos_date_dos2unix>
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
ffc21680: 88 01 00 27 lbz r0,39(r1)
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
date = *MSDOS_DIR_WRITE_DATE(node_entry);
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
ffc21684: 90 7d 00 40 stw r3,64(r29)
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
ffc21688: 70 09 00 10 andi. r9,r0,16
ffc2168c: 40 82 00 78 bne- ffc21704 <msdos_find_name+0x210>
ffc21690: 81 61 00 38 lwz r11,56(r1)
return rc;
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
ffc21694: 81 21 00 08 lwz r9,8(r1)
ffc21698: 51 60 46 3e rlwimi r0,r11,8,24,31
ffc2169c: 51 60 c4 2e rlwimi r0,r11,24,16,23
ffc216a0: 51 60 42 1e rlwimi r0,r11,8,8,15
ffc216a4: 51 60 c0 0e rlwimi r0,r11,24,0,7
fat_fd->fat_file_type = FAT_FILE;
ffc216a8: 39 60 00 05 li r11,5
return rc;
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
ffc216ac: 90 09 00 18 stw r0,24(r9)
fat_fd->fat_file_type = FAT_FILE;
ffc216b0: 91 69 00 10 stw r11,16(r9)
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
ffc216b4: 39 60 ff ff li r11,-1
ffc216b8: 91 69 00 14 stw r11,20(r9)
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
if ((fat_fd->fat_file_size != 0) &&
ffc216bc: 2f 80 00 00 cmpwi cr7,r0,0
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
}
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
ffc216c0: 81 69 00 1c lwz r11,28(r9)
fat_fd->fat_file_type = FAT_FILE;
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
}
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
ffc216c4: 39 40 00 00 li r10,0
ffc216c8: 91 49 00 34 stw r10,52(r9)
fat_fd->map.disk_cln = fat_fd->cln;
ffc216cc: 91 69 00 38 stw r11,56(r9)
if ((fat_fd->fat_file_size != 0) &&
ffc216d0: 41 9e 00 28 beq- cr7,ffc216f8 <msdos_find_name+0x204>
(fat_fd->fat_file_size <= fs_info->fat.vol.bpc))
ffc216d4: a1 5e 00 06 lhz r10,6(r30)
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
if ((fat_fd->fat_file_size != 0) &&
ffc216d8: 7f 8a 00 40 cmplw cr7,r10,r0
ffc216dc: 41 9c 00 1c blt- cr7,ffc216f8 <msdos_find_name+0x204> <== NEVER TAKEN
(fat_fd->fat_file_size <= fs_info->fat.vol.bpc))
{
fat_fd->map.last_cln = fat_fd->cln;
ffc216e0: 91 69 00 3c stw r11,60(r9)
ffc216e4: 4b ff ff 2c b ffc21610 <msdos_find_name+0x11c>
/* close fat-file corresponded to the node we searched in */
rc = fat_file_close(parent_loc->mt_entry, parent_loc->node_access);
if (rc != RC_OK)
{
fat_file_close(parent_loc->mt_entry, fat_fd);
ffc216e8: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc216ec: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
ffc216f0: 4b ff 61 91 bl ffc17880 <fat_file_close> <== NOT EXECUTED
return rc;
ffc216f4: 4b ff fe a4 b ffc21598 <msdos_find_name+0xa4> <== NOT EXECUTED
{
fat_fd->map.last_cln = fat_fd->cln;
}
else
{
fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
ffc216f8: 38 00 ff ff li r0,-1
ffc216fc: 90 09 00 3c stw r0,60(r9)
ffc21700: 4b ff ff 10 b ffc21610 <msdos_find_name+0x11c>
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
{
fat_fd->fat_file_type = FAT_DIRECTORY;
ffc21704: 81 21 00 08 lwz r9,8(r1)
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
ffc21708: 3c 00 00 20 lis r0,32
rc = fat_file_size(parent_loc->mt_entry, fat_fd);
ffc2170c: 80 7f 00 10 lwz r3,16(r31)
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
{
fat_fd->fat_file_type = FAT_DIRECTORY;
ffc21710: 93 89 00 10 stw r28,16(r9)
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
rc = fat_file_size(parent_loc->mt_entry, fat_fd);
ffc21714: 7d 24 4b 78 mr r4,r9
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
{
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
ffc21718: 90 09 00 14 stw r0,20(r9)
rc = fat_file_size(parent_loc->mt_entry, fat_fd);
ffc2171c: 4b ff 6a 89 bl ffc181a4 <fat_file_size>
if (rc != RC_OK)
ffc21720: 7c 7d 1b 79 mr. r29,r3
ffc21724: 40 a2 ff c4 bne- ffc216e8 <msdos_find_name+0x1f4> <== NEVER TAKEN
ffc21728: 81 21 00 08 lwz r9,8(r1)
ffc2172c: 80 09 00 18 lwz r0,24(r9)
ffc21730: 4b ff ff 8c b ffc216bc <msdos_find_name+0x1c8>
ffc203c4 <msdos_find_name_in_fat_file>:
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
ffc203c4: 7d 80 00 26 mfcr r12
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
assert(name_len > 0);
ffc203c8: 7c eb 3b 79 mr. r11,r7
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
ffc203cc: 94 21 ff 80 stwu r1,-128(r1)
ffc203d0: 7c 08 02 a6 mflr r0
ffc203d4: 90 01 00 84 stw r0,132(r1)
ffc203d8: 92 21 00 44 stw r17,68(r1)
ffc203dc: 93 a1 00 74 stw r29,116(r1)
ffc203e0: 7d 3d 4b 78 mr r29,r9
ffc203e4: 93 c1 00 78 stw r30,120(r1)
ffc203e8: 7c 7e 1b 78 mr r30,r3
ffc203ec: 93 e1 00 7c stw r31,124(r1)
ffc203f0: 7c 9f 23 78 mr r31,r4
ffc203f4: 91 c1 00 38 stw r14,56(r1)
ffc203f8: 91 e1 00 3c stw r15,60(r1)
ffc203fc: 92 01 00 40 stw r16,64(r1)
ffc20400: 92 41 00 48 stw r18,72(r1)
ffc20404: 92 61 00 4c stw r19,76(r1)
ffc20408: 92 81 00 50 stw r20,80(r1)
ffc2040c: 92 a1 00 54 stw r21,84(r1)
ffc20410: 92 c1 00 58 stw r22,88(r1)
ffc20414: 92 e1 00 5c stw r23,92(r1)
ffc20418: 93 01 00 60 stw r24,96(r1)
ffc2041c: 93 21 00 64 stw r25,100(r1)
ffc20420: 93 41 00 68 stw r26,104(r1)
ffc20424: 93 61 00 6c stw r27,108(r1)
ffc20428: 93 81 00 70 stw r28,112(r1)
ffc2042c: 91 81 00 34 stw r12,52(r1)
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
assert(name_len > 0);
ffc20430: 91 61 00 20 stw r11,32(r1)
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
ffc20434: 90 c1 00 28 stw r6,40(r1)
ffc20438: 91 01 00 24 stw r8,36(r1)
ffc2043c: 91 41 00 18 stw r10,24(r1)
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
ffc20440: 82 23 00 34 lwz r17,52(r3)
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
assert(name_len > 0);
ffc20444: 40 81 09 d8 ble- ffc20e1c <msdos_find_name_in_fat_file+0xa58><== NEVER TAKEN
* is short still check for possible long entries with the short name.
*
* In PR1491 we need to have a LFN for a short file name entry. To
* test this make this test always fail, ie add "0 &&".
*/
if (create_node && (name_type == MSDOS_NAME_SHORT))
ffc20448: 2e 05 00 00 cmpwi cr4,r5,0
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
ffc2044c: 38 00 ff ff li r0,-1
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
ffc20450: 39 20 00 00 li r9,0
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
ffc20454: 90 1d 00 08 stw r0,8(r29)
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
ffc20458: 91 3d 00 00 stw r9,0(r29)
dir_pos->sname.ofs = 0;
ffc2045c: 91 3d 00 04 stw r9,4(r29)
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
ffc20460: 90 1d 00 0c stw r0,12(r29)
assert(name_len > 0);
fat_dir_pos_init(dir_pos);
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
ffc20464: 90 01 00 10 stw r0,16(r1)
ffc20468: 90 01 00 0c stw r0,12(r1)
* is short still check for possible long entries with the short name.
*
* In PR1491 we need to have a LFN for a short file name entry. To
* test this make this test always fail, ie add "0 &&".
*/
if (create_node && (name_type == MSDOS_NAME_SHORT))
ffc2046c: 41 92 00 18 beq- cr4,ffc20484 <msdos_find_name_in_fat_file+0xc0>
ffc20470: 80 01 00 24 lwz r0,36(r1)
lfn_entries = 0;
ffc20474: 39 00 00 00 li r8,0
ffc20478: 91 01 00 1c stw r8,28(r1)
* is short still check for possible long entries with the short name.
*
* In PR1491 we need to have a LFN for a short file name entry. To
* test this make this test always fail, ie add "0 &&".
*/
if (create_node && (name_type == MSDOS_NAME_SHORT))
ffc2047c: 2f 80 00 01 cmpwi cr7,r0,1
ffc20480: 41 9e 00 28 beq- cr7,ffc204a8 <msdos_find_name_in_fat_file+0xe4>
lfn_entries = 0;
else
lfn_entries =
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
ffc20484: 81 61 00 20 lwz r11,32(r1)
* test this make this test always fail, ie add "0 &&".
*/
if (create_node && (name_type == MSDOS_NAME_SHORT))
lfn_entries = 0;
else
lfn_entries =
ffc20488: 3d 20 4e c4 lis r9,20164
ffc2048c: 61 29 ec 4f ori r9,r9,60495
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
ffc20490: 38 0b 00 0c addi r0,r11,12
* test this make this test always fail, ie add "0 &&".
*/
if (create_node && (name_type == MSDOS_NAME_SHORT))
lfn_entries = 0;
else
lfn_entries =
ffc20494: 7d 20 48 96 mulhw r9,r0,r9
ffc20498: 7c 00 fe 70 srawi r0,r0,31
ffc2049c: 7d 29 16 70 srawi r9,r9,2
ffc204a0: 7d 20 48 50 subf r9,r0,r9
ffc204a4: 91 21 00 1c stw r9,28(r1)
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
ffc204a8: 80 1f 00 20 lwz r0,32(r31)
ffc204ac: 2f 80 00 01 cmpwi cr7,r0,1
ffc204b0: 41 9e 05 d0 beq- cr7,ffc20a80 <msdos_find_name_in_fat_file+0x6bc>
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
ffc204b4: a3 31 00 06 lhz r25,6(r17)
* short and they match then we have the entry. We will not
* match a long file name against a short file name because
* a long file name that generates a matching short file
* name is not a long file name.
*/
if (lfn_matched ||
ffc204b8: 81 61 00 24 lwz r11,36(r1)
/*
* Scan the directory seeing if the file is present. While
* doing this see if a suitable location can be found to
* create the entry if the name is not found.
*/
while ((ret = fat_file_read(mt_entry, fat_fd, (dir_offset * bts2rd),
ffc204bc: 39 c0 00 00 li r14,0
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
ffc204c0: 81 01 00 1c lwz r8,28(r1)
int lfn_entries;
int lfn_entry = 0;
uint32_t empty_space_offset = 0;
uint32_t empty_space_entry = 0;
uint32_t empty_space_count = 0;
bool empty_space_found = false;
ffc204c4: 3a 40 00 00 li r18,0
* short and they match then we have the entry. We will not
* match a long file name against a short file name because
* a long file name that generates a matching short file
* name is not a long file name.
*/
if (lfn_matched ||
ffc204c8: 2d 8b 00 01 cmpwi cr3,r11,1
ffc204cc: 80 f1 00 9c lwz r7,156(r17)
ffc204d0: 83 61 00 28 lwz r27,40(r1)
uint8_t lfn_checksum = 0;
int lfn_entries;
int lfn_entry = 0;
uint32_t empty_space_offset = 0;
uint32_t empty_space_entry = 0;
uint32_t empty_space_count = 0;
ffc204d4: 3b 40 00 00 li r26,0
bool lfn_matched = false;
uint8_t lfn_checksum = 0;
int lfn_entries;
int lfn_entry = 0;
uint32_t empty_space_offset = 0;
uint32_t empty_space_entry = 0;
ffc204d8: 3a e0 00 00 li r23,0
fat_pos_t lfn_start;
bool lfn_matched = false;
uint8_t lfn_checksum = 0;
int lfn_entries;
int lfn_entry = 0;
uint32_t empty_space_offset = 0;
ffc204dc: 3a 80 00 00 li r20,0
uint32_t bts2rd = 0;
fat_pos_t lfn_start;
bool lfn_matched = false;
uint8_t lfn_checksum = 0;
int lfn_entries;
int lfn_entry = 0;
ffc204e0: 3a 60 00 00 li r19,0
uint32_t dir_offset = 0;
uint32_t dir_entry = 0;
uint32_t bts2rd = 0;
fat_pos_t lfn_start;
bool lfn_matched = false;
uint8_t lfn_checksum = 0;
ffc204e4: 3a 00 00 00 li r16,0
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_offset = 0;
uint32_t dir_entry = 0;
uint32_t bts2rd = 0;
fat_pos_t lfn_start;
bool lfn_matched = false;
ffc204e8: 3b 00 00 00 li r24,0
char *name_dir_entry
)
{
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_offset = 0;
ffc204ec: 3a a0 00 00 li r21,0
memcpy(name_dir_entry, entry,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
}
lfn_start.cln = FAT_FILE_SHORT_NAME;
ffc204f0: 3a c0 ff ff li r22,-1
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
ffc204f4: 39 e8 00 01 addi r15,r8,1
/*
* Scan the directory seeing if the file is present. While
* doing this see if a suitable location can be found to
* create the entry if the name is not found.
*/
while ((ret = fat_file_read(mt_entry, fat_fd, (dir_offset * bts2rd),
ffc204f8: 7f c3 f3 78 mr r3,r30
ffc204fc: 7f e4 fb 78 mr r4,r31
ffc20500: 7d c5 73 78 mr r5,r14
ffc20504: 7f 26 cb 78 mr r6,r25
ffc20508: 4b ff 6f b1 bl ffc174b8 <fat_file_read>
ffc2050c: 2c 03 00 00 cmpwi r3,0
ffc20510: 41 82 05 98 beq- ffc20aa8 <msdos_find_name_in_fat_file+0x6e4><== NEVER TAKEN
bool remainder_empty = false;
#if MSDOS_FIND_PRINT
printf ("MSFS:[2] dir_offset:%li\n", dir_offset);
#endif
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
ffc20514: 2f 83 00 1f cmpwi cr7,r3,31
ffc20518: 40 9d 05 a4 ble- cr7,ffc20abc <msdos_find_name_in_fat_file+0x6f8><== NEVER TAKEN
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
ffc2051c: 7f 83 c8 00 cmpw cr7,r3,r25
ffc20520: 40 9e 08 d8 bne- cr7,ffc20df8 <msdos_find_name_in_fat_file+0xa34><== NEVER TAKEN
ffc20524: 80 f1 00 9c lwz r7,156(r17)
ffc20528: 3b 80 00 00 li r28,0
ffc2052c: 7f 0b c3 78 mr r11,r24
* to here and write the long file name if this is the start of
* a series of empty entries. If empty_space_count is 0 then
* we are currently not inside an empty series of entries. It
* is a count of empty entries.
*/
if (empty_space_count == 0)
ffc20530: 2c 1a 00 00 cmpwi r26,0
/*
* See if the entry is empty or the remainder of the directory is
* empty ? Localise to make the code read better.
*/
bool entry_empty = (*MSDOS_DIR_ENTRY_TYPE(entry) ==
ffc20534: 7c 07 e0 ae lbzx r0,r7,r28
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (dir_entry = 0;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
ffc20538: 7f 07 e2 14 add r24,r7,r28
* to here and write the long file name if this is the start of
* a series of empty entries. If empty_space_count is 0 then
* we are currently not inside an empty series of entries. It
* is a count of empty entries.
*/
if (empty_space_count == 0)
ffc2053c: 40 82 00 0c bne- ffc20548 <msdos_find_name_in_fat_file+0x184><== NEVER TAKEN
ffc20540: 7f 97 e3 78 mr r23,r28
ffc20544: 7e b4 ab 78 mr r20,r21
{
empty_space_entry = dir_entry;
empty_space_offset = dir_offset;
}
if (remainder_empty)
ffc20548: 2f 80 00 00 cmpwi cr7,r0,0
ffc2054c: 41 9e 03 28 beq- cr7,ffc20874 <msdos_find_name_in_fat_file+0x4b0>
printf ("MSFS:[3.2] esf:%i esc%i\n", empty_space_found, empty_space_count);
#endif
}
break;
}
else if (entry_empty)
ffc20550: 2f 80 00 e5 cmpwi cr7,r0,229
ffc20554: 41 9e 00 b8 beq- cr7,ffc2060c <msdos_find_name_in_fat_file+0x248><== NEVER TAKEN
* A valid entry so handle it.
*
* If empty space has not been found we need to start the
* count again.
*/
if (create_node && !empty_space_found)
ffc20558: 41 92 00 14 beq- cr4,ffc2056c <msdos_find_name_in_fat_file+0x1a8>
ffc2055c: 2f 92 00 00 cmpwi cr7,r18,0
ffc20560: 40 9e 00 0c bne- cr7,ffc2056c <msdos_find_name_in_fat_file+0x1a8><== NEVER TAKEN
{
empty_space_entry = 0;
empty_space_count = 0;
ffc20564: 3b 40 00 00 li r26,0
* If empty space has not been found we need to start the
* count again.
*/
if (create_node && !empty_space_found)
{
empty_space_entry = 0;
ffc20568: 3a e0 00 00 li r23,0
/*
* Check the attribute to see if the entry is for a long
* file name.
*/
if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
ffc2056c: 89 38 00 0b lbz r9,11(r24)
ffc20570: 55 29 06 be clrlwi r9,r9,26
ffc20574: 2f 89 00 0f cmpwi cr7,r9,15
ffc20578: 41 9e 02 00 beq- cr7,ffc20778 <msdos_find_name_in_fat_file+0x3b4>
* If a LFN has been found and it matched check the
* entries have all been found and the checksum is
* correct. If this is the case return the short file
* name entry.
*/
if (lfn_matched)
ffc2057c: 2f 8b 00 00 cmpwi cr7,r11,0
ffc20580: 41 9e 00 64 beq- cr7,ffc205e4 <msdos_find_name_in_fat_file+0x220>
uint8_t cs = 0;
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(entry);
int i;
for (i = 0; i < MSDOS_SHORT_NAME_LEN; i++, p++)
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
ffc20584: 39 00 00 0b li r8,11
ffc20588: 7d 09 03 a6 mtctr r8
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
ffc2058c: 39 20 00 00 li r9,0
uint8_t cs = 0;
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(entry);
int i;
for (i = 0; i < MSDOS_SHORT_NAME_LEN; i++, p++)
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
ffc20590: 39 60 00 00 li r11,0
ffc20594: 55 29 f8 7e rlwinm r9,r9,31,1,31
ffc20598: 7d 60 5a 14 add r11,r0,r11
ffc2059c: 7d 29 5a 14 add r9,r9,r11
* If a LFN has been found and it matched check the
* entries have all been found and the checksum is
* correct. If this is the case return the short file
* name entry.
*/
if (lfn_matched)
ffc205a0: 7f 0a c3 78 mr r10,r24
uint8_t cs = 0;
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(entry);
int i;
for (i = 0; i < MSDOS_SHORT_NAME_LEN; i++, p++)
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
ffc205a4: 55 29 06 3e clrlwi r9,r9,24
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(entry);
int i;
for (i = 0; i < MSDOS_SHORT_NAME_LEN; i++, p++)
ffc205a8: 42 40 00 2c bdz- ffc205d4 <msdos_find_name_in_fat_file+0x210>
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
ffc205ac: 71 2b 00 01 andi. r11,r9,1
ffc205b0: 39 60 00 00 li r11,0
ffc205b4: 41 82 00 08 beq- ffc205bc <msdos_find_name_in_fat_file+0x1f8>
ffc205b8: 39 60 00 80 li r11,128
ffc205bc: 8c 0a 00 01 lbzu r0,1(r10)
ffc205c0: 55 29 f8 7e rlwinm r9,r9,31,1,31
ffc205c4: 7d 60 5a 14 add r11,r0,r11
ffc205c8: 7d 29 5a 14 add r9,r9,r11
ffc205cc: 55 29 06 3e clrlwi r9,r9,24
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(entry);
int i;
for (i = 0; i < MSDOS_SHORT_NAME_LEN; i++, p++)
ffc205d0: 42 00 ff dc bdnz+ ffc205ac <msdos_find_name_in_fat_file+0x1e8>
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entry || (lfn_checksum != cs))
ffc205d4: 2f 93 00 00 cmpwi cr7,r19,0
ffc205d8: 40 9e 00 0c bne- cr7,ffc205e4 <msdos_find_name_in_fat_file+0x220><== NEVER TAKEN
ffc205dc: 7f 90 48 00 cmpw cr7,r16,r9
ffc205e0: 41 9e 00 84 beq- cr7,ffc20664 <msdos_find_name_in_fat_file+0x2a0><== ALWAYS TAKEN
* short and they match then we have the entry. We will not
* match a long file name against a short file name because
* a long file name that generates a matching short file
* name is not a long file name.
*/
if (lfn_matched ||
ffc205e4: 41 8e 00 54 beq- cr3,ffc20638 <msdos_find_name_in_fat_file+0x274>
assert(ret == bts2rd);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (dir_entry = 0;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
ffc205e8: 3b 9c 00 20 addi r28,r28,32
memcpy(name_dir_entry, entry,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
}
lfn_start.cln = FAT_FILE_SHORT_NAME;
ffc205ec: 92 c1 00 0c stw r22,12(r1)
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (dir_entry = 0;
ffc205f0: 7f 99 e0 40 cmplw cr7,r25,r28
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
}
lfn_start.cln = FAT_FILE_SHORT_NAME;
lfn_matched = false;
ffc205f4: 39 60 00 00 li r11,0
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (dir_entry = 0;
ffc205f8: 41 9d ff 38 bgt+ cr7,ffc20530 <msdos_find_name_in_fat_file+0x16c><== ALWAYS TAKEN
ffc205fc: 7d 78 5b 78 mr r24,r11 <== NOT EXECUTED
ffc20600: 7d ce ca 14 add r14,r14,r25 <== NOT EXECUTED
}
if (remainder_empty)
break;
dir_offset++;
ffc20604: 3a b5 00 01 addi r21,r21,1 <== NOT EXECUTED
ffc20608: 4b ff fe f0 b ffc204f8 <msdos_find_name_in_fat_file+0x134><== NOT EXECUTED
}
break;
}
else if (entry_empty)
{
if (create_node)
ffc2060c: 41 92 00 10 beq- cr4,ffc2061c <msdos_find_name_in_fat_file+0x258><== NOT EXECUTED
{
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
ffc20610: 3b 5a 00 01 addi r26,r26,1 <== NOT EXECUTED
if (empty_space_count == (lfn_entries + 1))
ffc20614: 7f 8f d0 00 cmpw cr7,r15,r26 <== NOT EXECUTED
ffc20618: 41 9e 02 4c beq- cr7,ffc20864 <msdos_find_name_in_fat_file+0x4a0><== NOT EXECUTED
assert(ret == bts2rd);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (dir_entry = 0;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
ffc2061c: 3b 9c 00 20 addi r28,r28,32
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (dir_entry = 0;
ffc20620: 7f 99 e0 40 cmplw cr7,r25,r28
ffc20624: 41 9d ff 0c bgt+ cr7,ffc20530 <msdos_find_name_in_fat_file+0x16c><== ALWAYS TAKEN
ffc20628: 7d 78 5b 78 mr r24,r11 <== NOT EXECUTED
ffc2062c: 7d ce ca 14 add r14,r14,r25 <== NOT EXECUTED
}
if (remainder_empty)
break;
dir_offset++;
ffc20630: 3a b5 00 01 addi r21,r21,1 <== NOT EXECUTED
ffc20634: 4b ff fe c4 b ffc204f8 <msdos_find_name_in_fat_file+0x134><== NOT EXECUTED
* match a long file name against a short file name because
* a long file name that generates a matching short file
* name is not a long file name.
*/
if (lfn_matched ||
((name_type == MSDOS_NAME_SHORT) &&
ffc20638: 80 01 00 0c lwz r0,12(r1)
ffc2063c: 2f 80 ff ff cmpwi cr7,r0,-1
ffc20640: 40 9e ff a8 bne+ cr7,ffc205e8 <msdos_find_name_in_fat_file+0x224><== NEVER TAKEN
(lfn_start.cln == FAT_FILE_SHORT_NAME) &&
(memcmp(MSDOS_DIR_NAME(entry),
ffc20644: 80 81 00 18 lwz r4,24(r1)
ffc20648: 7f 03 c3 78 mr r3,r24
ffc2064c: 38 a0 00 0b li r5,11
ffc20650: 90 e1 00 2c stw r7,44(r1)
ffc20654: 48 00 49 4d bl ffc24fa0 <memcmp>
* a long file name that generates a matching short file
* name is not a long file name.
*/
if (lfn_matched ||
((name_type == MSDOS_NAME_SHORT) &&
(lfn_start.cln == FAT_FILE_SHORT_NAME) &&
ffc20658: 2f 83 00 00 cmpwi cr7,r3,0
ffc2065c: 80 e1 00 2c lwz r7,44(r1)
ffc20660: 40 9e ff 88 bne+ cr7,ffc205e8 <msdos_find_name_in_fat_file+0x224>
#endif
/*
* We get the entry we looked for - fill the position
* structure and the 32 bytes of the short entry
*/
int rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
ffc20664: 7f c3 f3 78 mr r3,r30
ffc20668: 7f e4 fb 78 mr r4,r31
ffc2066c: 38 a0 00 01 li r5,1
ffc20670: 7d c6 73 78 mr r6,r14
ffc20674: 7f a7 eb 78 mr r7,r29
ffc20678: 4c c6 31 82 crclr 4*cr1+eq
ffc2067c: 4b ff 73 01 bl ffc1797c <fat_file_ioctl>
ffc20680: 7f 1b c3 78 mr r27,r24
dir_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
ffc20684: 7c 75 1b 79 mr. r21,r3
ffc20688: 40 82 00 8c bne- ffc20714 <msdos_find_name_in_fat_file+0x350><== NEVER TAKEN
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
ffc2068c: 80 c1 00 0c lwz r6,12(r1)
dir_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = dir_entry;
ffc20690: 93 9d 00 04 stw r28,4(r29)
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
ffc20694: 2f 86 ff ff cmpwi cr7,r6,-1
ffc20698: 41 9e 04 1c beq- cr7,ffc20ab4 <msdos_find_name_in_fat_file+0x6f0>
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
ffc2069c: 7c d9 31 d6 mullw r6,r25,r6
ffc206a0: 7f c3 f3 78 mr r3,r30
ffc206a4: 7f e4 fb 78 mr r4,r31
ffc206a8: 38 a0 00 01 li r5,1
ffc206ac: 38 e1 00 0c addi r7,r1,12
ffc206b0: 4c c6 31 82 crclr 4*cr1+eq
ffc206b4: 4b ff 72 c9 bl ffc1797c <fat_file_ioctl>
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
ffc206b8: 2c 03 00 00 cmpwi r3,0
ffc206bc: 40 82 03 e4 bne- ffc20aa0 <msdos_find_name_in_fat_file+0x6dc><== NEVER TAKEN
ffc206c0: 80 01 00 0c lwz r0,12(r1)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
ffc206c4: 90 1d 00 08 stw r0,8(r29)
dir_pos->lname.ofs = lfn_start.ofs;
ffc206c8: 80 01 00 10 lwz r0,16(r1)
memcpy(name_dir_entry, entry,
ffc206cc: 81 01 00 18 lwz r8,24(r1)
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
ffc206d0: 90 1d 00 0c stw r0,12(r29)
memcpy(name_dir_entry, entry,
ffc206d4: 81 5b 00 00 lwz r10,0(r27)
ffc206d8: 81 7b 00 04 lwz r11,4(r27)
ffc206dc: 81 3b 00 08 lwz r9,8(r27)
ffc206e0: 80 1b 00 0c lwz r0,12(r27)
ffc206e4: 91 48 00 00 stw r10,0(r8)
ffc206e8: 91 68 00 04 stw r11,4(r8)
ffc206ec: 91 28 00 08 stw r9,8(r8)
ffc206f0: 90 08 00 0c stw r0,12(r8)
ffc206f4: 81 5b 00 10 lwz r10,16(r27)
ffc206f8: 81 7b 00 14 lwz r11,20(r27)
ffc206fc: 81 3b 00 18 lwz r9,24(r27)
ffc20700: 80 1b 00 1c lwz r0,28(r27)
ffc20704: 91 48 00 10 stw r10,16(r8)
ffc20708: 91 68 00 14 stw r11,20(r8)
ffc2070c: 91 28 00 18 stw r9,24(r8)
ffc20710: 90 08 00 1c stw r0,28(r8)
empty_space_entry = 0;
read_cluster = true;
}
return 0;
}
ffc20714: 80 01 00 84 lwz r0,132(r1)
ffc20718: 7e a3 ab 78 mr r3,r21
ffc2071c: 81 81 00 34 lwz r12,52(r1)
ffc20720: 7c 08 03 a6 mtlr r0
ffc20724: 81 c1 00 38 lwz r14,56(r1)
ffc20728: 81 e1 00 3c lwz r15,60(r1)
ffc2072c: 7d 81 81 20 mtcrf 24,r12
ffc20730: 82 01 00 40 lwz r16,64(r1)
ffc20734: 82 21 00 44 lwz r17,68(r1)
ffc20738: 82 41 00 48 lwz r18,72(r1)
ffc2073c: 82 61 00 4c lwz r19,76(r1)
ffc20740: 82 81 00 50 lwz r20,80(r1)
ffc20744: 82 a1 00 54 lwz r21,84(r1)
ffc20748: 82 c1 00 58 lwz r22,88(r1)
ffc2074c: 82 e1 00 5c lwz r23,92(r1)
ffc20750: 83 01 00 60 lwz r24,96(r1)
ffc20754: 83 21 00 64 lwz r25,100(r1)
ffc20758: 83 41 00 68 lwz r26,104(r1)
ffc2075c: 83 61 00 6c lwz r27,108(r1)
ffc20760: 83 81 00 70 lwz r28,112(r1)
ffc20764: 83 a1 00 74 lwz r29,116(r1)
ffc20768: 83 c1 00 78 lwz r30,120(r1)
ffc2076c: 83 e1 00 7c lwz r31,124(r1)
ffc20770: 38 21 00 80 addi r1,r1,128
ffc20774: 4e 80 00 20 blr
#endif
/*
* If we are not already processing a LFN see if this is
* the first entry of a LFN ?
*/
if (lfn_start.cln == FAT_FILE_SHORT_NAME)
ffc20778: 81 21 00 0c lwz r9,12(r1)
ffc2077c: 2f 89 ff ff cmpwi cr7,r9,-1
ffc20780: 41 9e 00 b0 beq- cr7,ffc20830 <msdos_find_name_in_fat_file+0x46c>
* If the entry number or the check sum do not match
* forget this series of long directory entries. These
* could be orphaned entries depending on the history
* of the disk.
*/
if ((lfn_entry != (*MSDOS_DIR_ENTRY_TYPE(entry) &
ffc20784: 54 00 06 be clrlwi r0,r0,26
ffc20788: 7f 80 98 00 cmpw cr7,r0,r19
ffc2078c: 41 9e 00 0c beq- cr7,ffc20798 <msdos_find_name_in_fat_file+0x3d4><== ALWAYS TAKEN
(lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry)))
{
#if MSDOS_FIND_PRINT
printf ("MSFS:[4.4] no match\n");
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
ffc20790: 92 c1 00 0c stw r22,12(r1) <== NOT EXECUTED
continue;
ffc20794: 4b ff fe 88 b ffc2061c <msdos_find_name_in_fat_file+0x258><== NOT EXECUTED
* forget this series of long directory entries. These
* could be orphaned entries depending on the history
* of the disk.
*/
if ((lfn_entry != (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK)) ||
ffc20798: 89 38 00 0d lbz r9,13(r24)
ffc2079c: 7f 89 80 00 cmpw cr7,r9,r16
ffc207a0: 40 9e ff f0 bne+ cr7,ffc20790 <msdos_find_name_in_fat_file+0x3cc><== NEVER TAKEN
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
ffc207a4: 3a 73 ff ff addi r19,r19,-1
ffc207a8: 81 61 00 20 lwz r11,32(r1)
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
ffc207ac: 1c d3 00 0d mulli r6,r19,13
ffc207b0: 7f 86 58 00 cmpw cr7,r6,r11
p = entry + 1;
ffc207b4: 7d 66 58 50 subf r11,r6,r11
ffc207b8: 39 6b 00 01 addi r11,r11,1
ffc207bc: 3b 18 00 01 addi r24,r24,1
ffc207c0: 7d 69 03 a6 mtctr r11
ffc207c4: 7c ca 33 78 mr r10,r6
ffc207c8: 39 20 00 01 li r9,1
ffc207cc: 41 9d 06 74 bgt- cr7,ffc20e40 <msdos_find_name_in_fat_file+0xa7c><== NEVER TAKEN
ffc207d0: 81 01 00 20 lwz r8,32(r1)
ffc207d4: 3d 60 80 00 lis r11,-32768
ffc207d8: 7f 88 58 00 cmpw cr7,r8,r11
ffc207dc: 40 be 00 24 bne+ cr7,ffc20800 <msdos_find_name_in_fat_file+0x43c><== ALWAYS TAKEN
ffc207e0: 48 00 06 60 b ffc20e40 <msdos_find_name_in_fat_file+0xa7c><== NOT EXECUTED
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
switch (i)
ffc207e4: 2f 88 00 0a cmpwi cr7,r8,10
ffc207e8: 41 9e 00 84 beq- cr7,ffc2086c <msdos_find_name_in_fat_file+0x4a8>
p = entry + 1;
#if MSDOS_FIND_PRINT
printf ("MSFS:[5] lfne:%i\n", lfn_entry);
#endif
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
ffc207ec: 2f 89 00 0d cmpwi cr7,r9,13
ffc207f0: 41 9e 02 6c beq- cr7,ffc20a5c <msdos_find_name_in_fat_file+0x698>
break;
case 10:
p += 4;
break;
default:
p += 2;
ffc207f4: 3b 18 00 02 addi r24,r24,2
continue;
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
p = entry + 1;
ffc207f8: 39 29 00 01 addi r9,r9,1
ffc207fc: 39 4a 00 01 addi r10,r10,1
{
#if MSDOS_FIND_PRINT > 1
printf ("MSFS:[6] o:%i i:%i *p:%c(%02x) name[o + i]:%c(%02x)\n",
o, i, *p, *p, name[o + i], name[o + i]);
#endif
if (*p == '\0')
ffc20800: 89 78 00 00 lbz r11,0(r24)
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
ffc20804: 39 09 ff ff addi r8,r9,-1
{
#if MSDOS_FIND_PRINT > 1
printf ("MSFS:[6] o:%i i:%i *p:%c(%02x) name[o + i]:%c(%02x)\n",
o, i, *p, *p, name[o + i], name[o + i]);
#endif
if (*p == '\0')
ffc20808: 2f 8b 00 00 cmpwi cr7,r11,0
ffc2080c: 41 9e 02 30 beq- cr7,ffc20a3c <msdos_find_name_in_fat_file+0x678>
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
ffc20810: 42 40 02 48 bdz- ffc20a58 <msdos_find_name_in_fat_file+0x694>
ffc20814: 7c bb 50 ae lbzx r5,r27,r10
ffc20818: 7f 85 58 00 cmpw cr7,r5,r11
ffc2081c: 40 9e 02 3c bne- cr7,ffc20a58 <msdos_find_name_in_fat_file+0x694>
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
switch (i)
ffc20820: 2f 88 00 04 cmpwi cr7,r8,4
ffc20824: 40 9e ff c0 bne+ cr7,ffc207e4 <msdos_find_name_in_fat_file+0x420>
{
case 4:
p += 5;
ffc20828: 3b 18 00 05 addi r24,r24,5
break;
ffc2082c: 4b ff ff cc b ffc207f8 <msdos_find_name_in_fat_file+0x434>
/*
* The first entry must have the last long entry
* flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
ffc20830: 70 0a 00 40 andi. r10,r0,64
* If we are not already processing a LFN see if this is
* the first entry of a LFN ?
*/
if (lfn_start.cln == FAT_FILE_SHORT_NAME)
{
lfn_matched = false;
ffc20834: 39 60 00 00 li r11,0
/*
* The first entry must have the last long entry
* flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
ffc20838: 41 a2 fd e4 beq- ffc2061c <msdos_find_name_in_fat_file+0x258>
* entry match the number we expect for this
* file name. Note we do not know the number of
* characters in the entry so this is check further
* on when the characters are checked.
*/
if (lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
ffc2083c: 81 01 00 1c lwz r8,28(r1)
ffc20840: 54 00 06 be clrlwi r0,r0,26
ffc20844: 7f 80 40 00 cmpw cr7,r0,r8
ffc20848: 40 9e fd d4 bne+ cr7,ffc2061c <msdos_find_name_in_fat_file+0x258>
continue;
/*
* Get the checksum of the short entry.
*/
lfn_start.cln = dir_offset;
ffc2084c: 92 a1 00 0c stw r21,12(r1)
lfn_start.ofs = dir_entry;
lfn_entry = lfn_entries;
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
ffc20850: 7d 13 43 78 mr r19,r8
/*
* Get the checksum of the short entry.
*/
lfn_start.cln = dir_offset;
lfn_start.ofs = dir_entry;
ffc20854: 93 81 00 10 stw r28,16(r1)
lfn_entry = lfn_entries;
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
ffc20858: 8a 18 00 0d lbz r16,13(r24)
ffc2085c: 88 18 00 00 lbz r0,0(r24)
ffc20860: 4b ff ff 24 b ffc20784 <msdos_find_name_in_fat_file+0x3c0>
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
empty_space_found = true;
ffc20864: 3a 40 00 01 li r18,1 <== NOT EXECUTED
ffc20868: 4b ff fd b4 b ffc2061c <msdos_find_name_in_fat_file+0x258><== NOT EXECUTED
{
case 4:
p += 5;
break;
case 10:
p += 4;
ffc2086c: 3b 18 00 04 addi r24,r24,4
break;
ffc20870: 4b ff ff 88 b ffc207f8 <msdos_find_name_in_fat_file+0x434>
#endif
/*
* If just looking and there is no more entries in the
* directory - return name-not-found
*/
if (!create_node)
ffc20874: 41 92 02 38 beq- cr4,ffc20aac <msdos_find_name_in_fat_file+0x6e8>
* Lets go and write the directory entries. If we have not found
* any available space add the remaining number of entries to any that
* we may have already found that are just before this entry. If more
* are needed FAT_EOF is returned by the read and we extend the file.
*/
if (!empty_space_found)
ffc20878: 2f 92 00 00 cmpwi cr7,r18,0
ffc2087c: 40 9e 00 14 bne- cr7,ffc20890 <msdos_find_name_in_fat_file+0x4cc><== NEVER TAKEN
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
entries_per_block = bts2rd / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
ffc20880: 57 20 d9 7e rlwinm r0,r25,27,5,31
* are needed FAT_EOF is returned by the read and we extend the file.
*/
if (!empty_space_found)
{
empty_space_count +=
entries_per_block - (dir_entry / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
ffc20884: 7f 5a 02 14 add r26,r26,r0
ffc20888: 57 9c d9 7e rlwinm r28,r28,27,5,31
ffc2088c: 7d 3c d0 51 subf. r9,r28,r26
* data to place in each long file name entry. First set the short
* file name to the slot of the SFN entry. This will mean no clashes
* in this directory.
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
ffc20890: 81 61 00 24 lwz r11,36(r1)
ffc20894: 2f 8b 00 02 cmpwi cr7,r11,2
ffc20898: 41 9e 02 e4 beq- cr7,ffc20b7c <msdos_find_name_in_fat_file+0x7b8>
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
msdos_short_name_hex(MSDOS_DIR_NAME(name_dir_entry), slot);
}
if (lfn_entries)
ffc2089c: 81 21 00 1c lwz r9,28(r1)
ffc208a0: 3a c0 00 00 li r22,0
ffc208a4: 2f 89 00 00 cmpwi cr7,r9,0
ffc208a8: 41 9e 00 64 beq- cr7,ffc2090c <msdos_find_name_in_fat_file+0x548>
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
lfn_checksum =
ffc208ac: 39 00 00 0b li r8,11
ffc208b0: 81 41 00 18 lwz r10,24(r1)
ffc208b4: 7d 09 03 a6 mtctr r8
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
msdos_short_name_hex(MSDOS_DIR_NAME(name_dir_entry), slot);
}
if (lfn_entries)
ffc208b8: 39 20 00 00 li r9,0
ffc208bc: 38 00 00 00 li r0,0
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
lfn_checksum =
ffc208c0: 56 d6 f8 7e rlwinm r22,r22,31,1,31
ffc208c4: 7d 6a 48 ae lbzx r11,r10,r9
ffc208c8: 7c 00 b2 14 add r0,r0,r22
ffc208cc: 7e c0 5a 14 add r22,r0,r11
ffc208d0: 56 d6 06 3e clrlwi r22,r22,24
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
ffc208d4: 39 29 00 01 addi r9,r9,1
ffc208d8: 42 40 00 34 bdz- ffc2090c <msdos_find_name_in_fat_file+0x548>
lfn_checksum =
ffc208dc: 56 cb 07 fe clrlwi r11,r22,31
ffc208e0: 2f 0b 00 00 cmpwi cr6,r11,0
ffc208e4: 38 00 00 00 li r0,0
ffc208e8: 41 ba ff d8 beq- cr6,ffc208c0 <msdos_find_name_in_fat_file+0x4fc>
ffc208ec: 56 d6 f8 7e rlwinm r22,r22,31,1,31
ffc208f0: 7d 6a 48 ae lbzx r11,r10,r9
ffc208f4: 38 00 00 80 li r0,128
ffc208f8: 7c 00 b2 14 add r0,r0,r22
ffc208fc: 7e c0 5a 14 add r22,r0,r11
ffc20900: 56 d6 06 3e clrlwi r22,r22,24
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
ffc20904: 39 29 00 01 addi r9,r9,1
ffc20908: 42 00 ff d4 bdnz+ ffc208dc <msdos_find_name_in_fat_file+0x518>
* empty_space_count is a count of empty entries in the currently
* read cluster so if 0 there is no space. Note, dir_offset will
* be at the next cluster so we can just make empty_space_offset
* that value.
*/
if (empty_space_count == 0)
ffc2090c: 41 82 02 60 beq- ffc20b6c <msdos_find_name_in_fat_file+0x7a8><== NEVER TAKEN
}
/*
* Have we read past the empty block ? If so go back and read it again.
*/
if (dir_offset != empty_space_offset)
ffc20910: 7f 14 a8 00 cmpw cr6,r20,r21
read_cluster = true;
ffc20914: 38 00 00 01 li r0,1
}
/*
* Have we read past the empty block ? If so go back and read it again.
*/
if (dir_offset != empty_space_offset)
ffc20918: 41 9a 04 d8 beq- cr6,ffc20df0 <msdos_find_name_in_fat_file+0xa2c><== ALWAYS TAKEN
read_cluster = true;
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
ffc2091c: 39 20 ff ff li r9,-1
ffc20920: 91 21 00 10 stw r9,16(r1)
ffc20924: 91 21 00 0c stw r9,12(r1)
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
ffc20928: 41 9c 04 40 blt- cr7,ffc20d68 <msdos_find_name_in_fat_file+0x9a4><== NEVER TAKEN
{
int length = 0;
if (read_cluster)
ffc2092c: 2f 80 00 00 cmpwi cr7,r0,0
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
ffc20930: 7e 74 c9 d6 mullw r19,r20,r25
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
lfn_entry = 0;
ffc20934: 3b 60 00 00 li r27,0
*/
while (lfn_entry < (lfn_entries + 1))
{
int length = 0;
if (read_cluster)
ffc20938: 40 9e 01 98 bne- cr7,ffc20ad0 <msdos_find_name_in_fat_file+0x70c><== NEVER TAKEN
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
ffc2093c: 7f 99 b8 40 cmplw cr7,r25,r23
ffc20940: 40 9d 04 9c ble- cr7,ffc20ddc <msdos_find_name_in_fat_file+0xa18><== NEVER TAKEN
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
ffc20944: 81 21 00 1c lwz r9,28(r1)
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
lfn_entry++;
ffc20948: 3b 5b 00 01 addi r26,r27,1
for (dir_entry = empty_space_entry;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
ffc2094c: 83 91 00 9c lwz r28,156(r17)
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
ffc20950: 38 69 00 01 addi r3,r9,1
ffc20954: 7f 83 d0 00 cmpw cr7,r3,r26
for (dir_entry = empty_space_entry;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
ffc20958: 7f 9c ba 14 add r28,r28,r23
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
ffc2095c: 41 9e 04 74 beq- cr7,ffc20dd0 <msdos_find_name_in_fat_file+0xa0c>
dir_pos->lname.ofs = lfn_start.ofs;
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
break;
ffc20960: 81 21 00 1c lwz r9,28(r1)
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
ffc20964: 7f 64 d8 f8 not r4,r27
ffc20968: 81 61 00 28 lwz r11,40(r1)
ffc2096c: 7e fb bb 78 mr r27,r23
dir_pos->lname.ofs = lfn_start.ofs;
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
break;
ffc20970: 55 25 06 3e clrlwi r5,r9,24
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
ffc20974: 7c 84 4a 14 add r4,r4,r9
dir_pos->lname.ofs = lfn_start.ofs;
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
break;
ffc20978: 38 a5 00 01 addi r5,r5,1
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
ffc2097c: 1c 84 00 0d mulli r4,r4,13
dir_pos->lname.ofs = lfn_start.ofs;
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
break;
ffc20980: 7c ba 28 50 subf r5,r26,r5
ffc20984: 54 a5 06 3e clrlwi r5,r5,24
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
ffc20988: 7c 8b 22 14 add r4,r11,r4
char* p;
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
ffc2098c: 3b 00 00 20 li r24,32
}
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
ffc20990: 38 c0 00 00 li r6,0
* This is a long file name and we need to write
* a long file name entry. See if this is the
* first entry written and if so remember the
* the location of the long file name.
*/
if (lfn_start.cln == FAT_FILE_SHORT_NAME)
ffc20994: 80 01 00 0c lwz r0,12(r1)
ffc20998: 2f 80 ff ff cmpwi cr7,r0,-1
ffc2099c: 41 9e 04 00 beq- cr7,ffc20d9c <msdos_find_name_in_fat_file+0x9d8>
}
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
ffc209a0: 90 dc 00 0c stw r6,12(r28)
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
ffc209a4: 7c 88 23 78 mr r8,r4
ffc209a8: 39 60 00 01 li r11,1
}
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
ffc209ac: 90 dc 00 00 stw r6,0(r28)
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
ffc209b0: 39 3c 00 01 addi r9,r28,1
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
char* p;
const char* n;
int i;
char fill = 0;
ffc209b4: 38 e0 00 00 li r7,0
}
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
ffc209b8: 90 dc 00 04 stw r6,4(r28)
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
ffc209bc: 38 0b ff ff addi r0,r11,-1
}
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
ffc209c0: 90 dc 00 08 stw r6,8(r28)
ffc209c4: 90 dc 00 10 stw r6,16(r28)
ffc209c8: 90 dc 00 14 stw r6,20(r28)
ffc209cc: 90 dc 00 18 stw r6,24(r28)
ffc209d0: 90 dc 00 1c stw r6,28(r28)
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
ffc209d4: 9a dc 00 0d stb r22,13(r28)
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
{
if (*n != 0)
ffc209d8: 89 48 00 00 lbz r10,0(r8)
ffc209dc: 2f 8a 00 00 cmpwi cr7,r10,0
ffc209e0: 41 9e 00 3c beq- cr7,ffc20a1c <msdos_find_name_in_fat_file+0x658><== NEVER TAKEN
p [0] = fill;
p [1] = fill;
fill = 0xff;
}
switch (i)
ffc209e4: 2f 80 00 04 cmpwi cr7,r0,4
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
{
if (*n != 0)
{
*p = *n;
ffc209e8: 99 49 00 00 stb r10,0(r9)
n++;
ffc209ec: 39 08 00 01 addi r8,r8,1
p [0] = fill;
p [1] = fill;
fill = 0xff;
}
switch (i)
ffc209f0: 41 9e 00 40 beq- cr7,ffc20a30 <msdos_find_name_in_fat_file+0x66c>
ffc209f4: 2f 80 00 0a cmpwi cr7,r0,10
ffc209f8: 41 9e 02 18 beq- cr7,ffc20c10 <msdos_find_name_in_fat_file+0x84c>
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
ffc209fc: 2f 8b 00 0d cmpwi cr7,r11,13
ffc20a00: 41 9e 02 1c beq- cr7,ffc20c1c <msdos_find_name_in_fat_file+0x858>
break;
case 10:
p += 4;
break;
default:
p += 2;
ffc20a04: 39 29 00 02 addi r9,r9,2
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
ffc20a08: 39 6b 00 01 addi r11,r11,1
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
{
if (*n != 0)
ffc20a0c: 89 48 00 00 lbz r10,0(r8)
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
ffc20a10: 38 0b ff ff addi r0,r11,-1
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
{
if (*n != 0)
ffc20a14: 2f 8a 00 00 cmpwi cr7,r10,0
ffc20a18: 40 be ff cc bne- cr7,ffc209e4 <msdos_find_name_in_fat_file+0x620>
p [0] = fill;
p [1] = fill;
fill = 0xff;
}
switch (i)
ffc20a1c: 2f 80 00 04 cmpwi cr7,r0,4
*p = *n;
n++;
}
else
{
p [0] = fill;
ffc20a20: 98 e9 00 00 stb r7,0(r9)
p [1] = fill;
ffc20a24: 98 e9 00 01 stb r7,1(r9)
fill = 0xff;
ffc20a28: 38 e0 00 ff li r7,255
}
switch (i)
ffc20a2c: 40 9e ff c8 bne+ cr7,ffc209f4 <msdos_find_name_in_fat_file+0x630>
{
case 4:
p += 5;
ffc20a30: 39 29 00 05 addi r9,r9,5
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
ffc20a34: 39 6b 00 01 addi r11,r11,1
ffc20a38: 4b ff ff d4 b ffc20a0c <msdos_find_name_in_fat_file+0x648>
/*
* If this is the first entry, ie the last part of the
* long file name and the length does not match then
* the file names do not match.
*/
if (((lfn_entry + 1) == lfn_entries) &&
ffc20a3c: 81 21 00 1c lwz r9,28(r1)
ffc20a40: 7f 89 00 00 cmpw cr7,r9,r0
ffc20a44: 40 be 00 18 bne+ cr7,ffc20a5c <msdos_find_name_in_fat_file+0x698><== NEVER TAKEN
ffc20a48: 81 61 00 20 lwz r11,32(r1)
((o + i) != name_len))
ffc20a4c: 7d 06 42 14 add r8,r6,r8
/*
* If this is the first entry, ie the last part of the
* long file name and the length does not match then
* the file names do not match.
*/
if (((lfn_entry + 1) == lfn_entries) &&
ffc20a50: 7f 88 58 00 cmpw cr7,r8,r11
ffc20a54: 41 9e 00 08 beq- cr7,ffc20a5c <msdos_find_name_in_fat_file+0x698><== ALWAYS TAKEN
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
ffc20a58: 92 c1 00 0c stw r22,12(r1)
p += 2;
break;
}
}
lfn_matched = ((lfn_entry == 0) &&
ffc20a5c: 2f 93 00 00 cmpwi cr7,r19,0
ffc20a60: 39 60 00 00 li r11,0
ffc20a64: 40 be fb b8 bne- cr7,ffc2061c <msdos_find_name_in_fat_file+0x258>
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
ffc20a68: 81 61 00 0c lwz r11,12(r1)
ffc20a6c: 39 6b 00 01 addi r11,r11,1
ffc20a70: 7d 6b 00 34 cntlzw r11,r11
ffc20a74: 55 6b d9 7e rlwinm r11,r11,27,5,31
ffc20a78: 69 6b 00 01 xori r11,r11,1
ffc20a7c: 4b ff fb a0 b ffc2061c <msdos_find_name_in_fat_file+0x258>
lfn_entries = 0;
else
lfn_entries =
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
ffc20a80: 80 1f 00 24 lwz r0,36(r31)
ffc20a84: 2f 80 00 00 cmpwi cr7,r0,0
ffc20a88: 40 be fa 2c bne- cr7,ffc204b4 <msdos_find_name_in_fat_file+0xf0><== NEVER TAKEN
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
ffc20a8c: 88 11 00 0a lbz r0,10(r17)
lfn_entries = 0;
else
lfn_entries =
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
ffc20a90: 70 08 00 03 andi. r8,r0,3
ffc20a94: 41 a2 fa 20 beq- ffc204b4 <msdos_find_name_in_fat_file+0xf0><== NEVER TAKEN
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
ffc20a98: 83 3f 00 18 lwz r25,24(r31)
ffc20a9c: 4b ff fa 1c b ffc204b8 <msdos_find_name_in_fat_file+0xf4>
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
ffc20aa0: 7c 75 1b 78 mr r21,r3 <== NOT EXECUTED
ffc20aa4: 4b ff fc 70 b ffc20714 <msdos_find_name_in_fat_file+0x350><== NOT EXECUTED
}
/*
* If we are not to create the entry return a not found error.
*/
if (!create_node)
ffc20aa8: 40 92 03 40 bne- cr4,ffc20de8 <msdos_find_name_in_fat_file+0xa24><== NOT EXECUTED
return MSDOS_NAME_NOT_FOUND_ERR;
ffc20aac: 3a a0 7d 01 li r21,32001
ffc20ab0: 4b ff fc 64 b ffc20714 <msdos_find_name_in_fat_file+0x350>
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
ffc20ab4: 38 00 ff ff li r0,-1
ffc20ab8: 4b ff fc 0c b ffc206c4 <msdos_find_name_in_fat_file+0x300>
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.3] extended: %d <-> %d\n", new_length, empty_space_offset * bts2rd);
#endif
if (new_length != (empty_space_offset * bts2rd))
rtems_set_errno_and_return_minus_one(EIO);
ffc20abc: 48 00 37 55 bl ffc24210 <__errno> <== NOT EXECUTED
ffc20ac0: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc20ac4: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc20ac8: 3a a0 ff ff li r21,-1 <== NOT EXECUTED
ffc20acc: 4b ff fc 48 b ffc20714 <msdos_find_name_in_fat_file+0x350><== NOT EXECUTED
{
uint32_t new_length;
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.1] eso:%li\n", empty_space_offset);
#endif
ret = fat_file_read(mt_entry, fat_fd,
ffc20ad0: 80 f1 00 9c lwz r7,156(r17) <== NOT EXECUTED
ffc20ad4: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc20ad8: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc20adc: 7e 65 9b 78 mr r5,r19 <== NOT EXECUTED
ffc20ae0: 7f 26 cb 78 mr r6,r25 <== NOT EXECUTED
ffc20ae4: 4b ff 69 d5 bl ffc174b8 <fat_file_read> <== NOT EXECUTED
(empty_space_offset * bts2rd), bts2rd,
fs_info->cl_buf);
if (ret != bts2rd)
ffc20ae8: 7f 83 c8 00 cmpw cr7,r3,r25 <== NOT EXECUTED
ffc20aec: 41 be fe 50 beq- cr7,ffc2093c <msdos_find_name_in_fat_file+0x578><== NOT EXECUTED
{
if (ret != FAT_EOF)
ffc20af0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc20af4: 40 be ff c8 bne- cr7,ffc20abc <msdos_find_name_in_fat_file+0x6f8><== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.2] extending file:%li\n", empty_space_offset);
#endif
ret = fat_file_extend (mt_entry, fat_fd, empty_space_offset * bts2rd,
ffc20af8: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc20afc: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc20b00: 7e 65 9b 78 mr r5,r19 <== NOT EXECUTED
ffc20b04: 38 c1 00 08 addi r6,r1,8 <== NOT EXECUTED
ffc20b08: 4b ff 6f 79 bl ffc17a80 <fat_file_extend> <== NOT EXECUTED
&new_length);
if (ret != RC_OK)
ffc20b0c: 7c 75 1b 79 mr. r21,r3 <== NOT EXECUTED
ffc20b10: 40 a2 fc 04 bne- ffc20714 <msdos_find_name_in_fat_file+0x350><== NOT EXECUTED
return ret;
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.3] extended: %d <-> %d\n", new_length, empty_space_offset * bts2rd);
#endif
if (new_length != (empty_space_offset * bts2rd))
ffc20b14: 80 01 00 08 lwz r0,8(r1) <== NOT EXECUTED
ffc20b18: 7f 80 98 00 cmpw cr7,r0,r19 <== NOT EXECUTED
ffc20b1c: 40 be ff a0 bne- cr7,ffc20abc <msdos_find_name_in_fat_file+0x6f8><== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
memset(fs_info->cl_buf, 0, bts2rd);
ffc20b20: 80 71 00 9c lwz r3,156(r17) <== NOT EXECUTED
ffc20b24: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc20b28: 7f 25 cb 78 mr r5,r25 <== NOT EXECUTED
ffc20b2c: 48 00 45 fd bl ffc25128 <memset> <== NOT EXECUTED
ret = fat_file_write(mt_entry, fat_fd,
ffc20b30: 80 f1 00 9c lwz r7,156(r17) <== NOT EXECUTED
ffc20b34: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc20b38: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc20b3c: 7e 65 9b 78 mr r5,r19 <== NOT EXECUTED
ffc20b40: 7f 26 cb 78 mr r6,r25 <== NOT EXECUTED
ffc20b44: 4b ff 71 7d bl ffc17cc0 <fat_file_write> <== NOT EXECUTED
empty_space_offset * bts2rd,
bts2rd, fs_info->cl_buf);
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.4] clear write: %d\n", ret);
#endif
if (ret == -1)
ffc20b48: 3a a0 ff ff li r21,-1 <== NOT EXECUTED
ffc20b4c: 2f 83 ff ff cmpwi cr7,r3,-1 <== NOT EXECUTED
ffc20b50: 41 be fb c4 beq- cr7,ffc20714 <msdos_find_name_in_fat_file+0x350><== NOT EXECUTED
return ret;
else if (ret != bts2rd)
ffc20b54: 7f 83 c8 00 cmpw cr7,r3,r25 <== NOT EXECUTED
ffc20b58: 41 9e fd e4 beq+ cr7,ffc2093c <msdos_find_name_in_fat_file+0x578><== NOT EXECUTED
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
return ret;
else if (ret != length)
rtems_set_errno_and_return_minus_one(EIO);
ffc20b5c: 48 00 36 b5 bl ffc24210 <__errno> <== NOT EXECUTED
ffc20b60: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc20b64: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc20b68: 4b ff fb ac b ffc20714 <msdos_find_name_in_fat_file+0x350><== NOT EXECUTED
* empty_space_count is a count of empty entries in the currently
* read cluster so if 0 there is no space. Note, dir_offset will
* be at the next cluster so we can just make empty_space_offset
* that value.
*/
if (empty_space_count == 0)
ffc20b6c: 7e b4 ab 78 mr r20,r21 <== NOT EXECUTED
{
read_cluster = true;
ffc20b70: 38 00 00 01 li r0,1 <== NOT EXECUTED
empty_space_offset = dir_offset;
empty_space_entry = 0;
ffc20b74: 3a e0 00 00 li r23,0 <== NOT EXECUTED
ffc20b78: 4b ff fd a4 b ffc2091c <msdos_find_name_in_fat_file+0x558><== NOT EXECUTED
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
ffc20b7c: 81 01 00 18 lwz r8,24(r1)
* in this directory.
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
ffc20b80: 7d 34 c9 d6 mullw r9,r20,r25
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
ffc20b84: 81 41 00 1c lwz r10,28(r1)
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
ffc20b88: 88 08 00 00 lbz r0,0(r8)
* in this directory.
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
ffc20b8c: 7d 29 ba 14 add r9,r9,r23
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
ffc20b90: 2f 80 00 20 cmpwi cr7,r0,32
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
ffc20b94: 39 0a 00 01 addi r8,r10,1
* in this directory.
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
ffc20b98: 55 29 d9 7e rlwinm r9,r9,27,5,31
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
ffc20b9c: 7d 08 4a 14 add r8,r8,r9
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
ffc20ba0: 41 9e 02 20 beq- cr7,ffc20dc0 <msdos_find_name_in_fat_file+0x9fc><== NEVER TAKEN
ffc20ba4: 2f 80 00 2e cmpwi cr7,r0,46
ffc20ba8: 41 9e 02 18 beq- cr7,ffc20dc0 <msdos_find_name_in_fat_file+0x9fc><== NEVER TAKEN
ffc20bac: 81 21 00 18 lwz r9,24(r1)
ffc20bb0: 88 09 00 01 lbz r0,1(r9)
ffc20bb4: 2f 80 00 20 cmpwi cr7,r0,32
ffc20bb8: 41 9e 01 f8 beq- cr7,ffc20db0 <msdos_find_name_in_fat_file+0x9ec><== NEVER TAKEN
ffc20bbc: 2f 80 00 2e cmpwi cr7,r0,46
ffc20bc0: 41 9e 01 f0 beq- cr7,ffc20db0 <msdos_find_name_in_fat_file+0x9ec><== NEVER TAKEN
ffc20bc4: 38 00 00 04 li r0,4
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
ffc20bc8: 81 21 00 18 lwz r9,24(r1)
ffc20bcc: 7c 09 03 a6 mtctr r0
ffc20bd0: 3d 40 ff c3 lis r10,-61
ffc20bd4: 39 69 00 01 addi r11,r9,1
ffc20bd8: 39 4a 4d d8 addi r10,r10,19928
ffc20bdc: 39 20 00 0c li r9,12
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
ffc20be0: 7d 00 4e 30 sraw r0,r8,r9
ffc20be4: 54 00 07 3e clrlwi r0,r0,28
ffc20be8: 7c 0a 00 ae lbzx r0,r10,r0
ffc20bec: 39 29 ff fc addi r9,r9,-4
ffc20bf0: 9c 0b 00 01 stbu r0,1(r11)
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
ffc20bf4: 42 00 ff ec bdnz+ ffc20be0 <msdos_find_name_in_fat_file+0x81c>
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
*c++ = '~';
ffc20bf8: 81 01 00 18 lwz r8,24(r1)
ffc20bfc: 38 00 00 7e li r0,126
ffc20c00: 98 08 00 06 stb r0,6(r8)
*c++ = '1';
ffc20c04: 38 00 00 31 li r0,49
ffc20c08: 98 08 00 07 stb r0,7(r8)
ffc20c0c: 4b ff fc 90 b ffc2089c <msdos_find_name_in_fat_file+0x4d8>
{
case 4:
p += 5;
break;
case 10:
p += 4;
ffc20c10: 39 29 00 04 addi r9,r9,4
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
ffc20c14: 39 6b 00 01 addi r11,r11,1
ffc20c18: 4b ff fd f4 b ffc20a0c <msdos_find_name_in_fat_file+0x648>
break;
}
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
ffc20c1c: 2f 9a 00 01 cmpwi cr7,r26,1
p += 2;
break;
}
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
ffc20c20: 98 bc 00 00 stb r5,0(r28)
if (lfn_entry == 1)
ffc20c24: 41 9e 01 4c beq- cr7,ffc20d70 <msdos_find_name_in_fat_file+0x9ac>
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
ffc20c28: 3b 7b 00 20 addi r27,r27,32
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
ffc20c2c: 88 1c 00 0b lbz r0,11(r28)
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
ffc20c30: 7f 99 d8 40 cmplw cr7,r25,r27
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
ffc20c34: 60 00 00 0f ori r0,r0,15
ffc20c38: 98 1c 00 0b stb r0,11(r28)
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
ffc20c3c: 40 9d 01 54 ble- cr7,ffc20d90 <msdos_find_name_in_fat_file+0x9cc><== NEVER TAKEN
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
lfn_entry++;
ffc20c40: 3b 5a 00 01 addi r26,r26,1
for (dir_entry = empty_space_entry;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
ffc20c44: 83 91 00 9c lwz r28,156(r17)
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
ffc20c48: 7f 83 d0 00 cmpw cr7,r3,r26
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
lfn_entry++;
ffc20c4c: 38 a5 ff ff addi r5,r5,-1
for (dir_entry = empty_space_entry;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
ffc20c50: 7f 9c da 14 add r28,r28,r27
char* p;
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
ffc20c54: 3b 18 00 20 addi r24,r24,32
lfn_entry++;
ffc20c58: 54 a5 06 3e clrlwi r5,r5,24
ffc20c5c: 38 84 ff f3 addi r4,r4,-13
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
ffc20c60: 40 9e fd 34 bne+ cr7,ffc20994 <msdos_find_name_in_fat_file+0x5d0>
{
/* get current cluster number */
int rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
ffc20c64: 7f c3 f3 78 mr r3,r30
ffc20c68: 7f e4 fb 78 mr r4,r31
ffc20c6c: 38 a0 00 01 li r5,1
ffc20c70: 7e 66 9b 78 mr r6,r19
ffc20c74: 7f a7 eb 78 mr r7,r29
ffc20c78: 4c c6 31 82 crclr 4*cr1+eq
ffc20c7c: 4b ff 6d 01 bl ffc1797c <fat_file_ioctl>
empty_space_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
ffc20c80: 2f 83 00 00 cmpwi cr7,r3,0
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
{
/* get current cluster number */
int rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
ffc20c84: 7c 75 1b 78 mr r21,r3
empty_space_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
ffc20c88: 40 be fa 8c bne- cr7,ffc20714 <msdos_find_name_in_fat_file+0x350><== NEVER TAKEN
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
ffc20c8c: 80 c1 00 0c lwz r6,12(r1)
empty_space_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = dir_entry;
ffc20c90: 93 7d 00 04 stw r27,4(r29)
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
ffc20c94: 2f 86 ff ff cmpwi cr7,r6,-1
ffc20c98: 41 9e 01 10 beq- cr7,ffc20da8 <msdos_find_name_in_fat_file+0x9e4>
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
ffc20c9c: 7c d9 31 d6 mullw r6,r25,r6
ffc20ca0: 7f c3 f3 78 mr r3,r30
ffc20ca4: 7f e4 fb 78 mr r4,r31
ffc20ca8: 38 a0 00 01 li r5,1
ffc20cac: 38 e1 00 0c addi r7,r1,12
ffc20cb0: 4c c6 31 82 crclr 4*cr1+eq
ffc20cb4: 4b ff 6c c9 bl ffc1797c <fat_file_ioctl>
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
ffc20cb8: 80 01 00 0c lwz r0,12(r1)
ffc20cbc: 2f 83 00 00 cmpwi cr7,r3,0
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
ffc20cc0: 7c 75 1b 78 mr r21,r3
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
ffc20cc4: 40 be fa 50 bne- cr7,ffc20714 <msdos_find_name_in_fat_file+0x350><== NEVER TAKEN
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
ffc20cc8: 90 1d 00 08 stw r0,8(r29)
dir_pos->lname.ofs = lfn_start.ofs;
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
ffc20ccc: 7f 06 c3 78 mr r6,r24
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
lfn_entry++;
ffc20cd0: 7f 5b d3 78 mr r27,r26
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
ffc20cd4: 80 01 00 10 lwz r0,16(r1)
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
ffc20cd8: 81 01 00 18 lwz r8,24(r1)
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
ffc20cdc: 90 1d 00 0c stw r0,12(r29)
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
ffc20ce0: 81 61 00 18 lwz r11,24(r1)
ffc20ce4: 81 28 00 08 lwz r9,8(r8)
ffc20ce8: 81 4b 00 00 lwz r10,0(r11)
ffc20cec: 80 08 00 0c lwz r0,12(r8)
ffc20cf0: 81 6b 00 04 lwz r11,4(r11)
ffc20cf4: 91 5c 00 00 stw r10,0(r28)
ffc20cf8: 91 7c 00 04 stw r11,4(r28)
ffc20cfc: 91 3c 00 08 stw r9,8(r28)
ffc20d00: 90 1c 00 0c stw r0,12(r28)
ffc20d04: 81 48 00 10 lwz r10,16(r8)
ffc20d08: 81 68 00 14 lwz r11,20(r8)
ffc20d0c: 81 28 00 18 lwz r9,24(r8)
ffc20d10: 80 08 00 1c lwz r0,28(r8)
ffc20d14: 91 5c 00 10 stw r10,16(r28)
ffc20d18: 91 7c 00 14 stw r11,20(r28)
ffc20d1c: 91 3c 00 18 stw r9,24(r28)
ffc20d20: 90 1c 00 1c stw r0,28(r28)
if (lfn_entry == 1)
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
}
ret = fat_file_write(mt_entry, fat_fd,
ffc20d24: 80 f1 00 9c lwz r7,156(r17)
ffc20d28: 7f c3 f3 78 mr r3,r30
ffc20d2c: 7f e4 fb 78 mr r4,r31
ffc20d30: 7c b3 ba 14 add r5,r19,r23
ffc20d34: 7c e7 ba 14 add r7,r7,r23
ffc20d38: 4b ff 6f 89 bl ffc17cc0 <fat_file_write>
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
ffc20d3c: 3a a0 ff ff li r21,-1
ffc20d40: 2f 83 ff ff cmpwi cr7,r3,-1
ffc20d44: 41 be f9 d0 beq- cr7,ffc20714 <msdos_find_name_in_fat_file+0x350><== NEVER TAKEN
return ret;
else if (ret != length)
ffc20d48: 7f 83 c0 00 cmpw cr7,r3,r24
ffc20d4c: 40 be fe 10 bne- cr7,ffc20b5c <msdos_find_name_in_fat_file+0x798><== NEVER TAKEN
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
ffc20d50: 81 01 00 1c lwz r8,28(r1)
if (ret == -1)
return ret;
else if (ret != length)
rtems_set_errno_and_return_minus_one(EIO);
empty_space_offset++;
ffc20d54: 3a 94 00 01 addi r20,r20,1
ffc20d58: 7e 73 ca 14 add r19,r19,r25
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
ffc20d5c: 7f 88 d8 00 cmpw cr7,r8,r27
return ret;
else if (ret != length)
rtems_set_errno_and_return_minus_one(EIO);
empty_space_offset++;
empty_space_entry = 0;
ffc20d60: 3a e0 00 00 li r23,0
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
ffc20d64: 40 9c fd 6c bge+ cr7,ffc20ad0 <msdos_find_name_in_fat_file+0x70c><== NEVER TAKEN
empty_space_offset++;
empty_space_entry = 0;
read_cluster = true;
}
return 0;
ffc20d68: 3a a0 00 00 li r21,0
ffc20d6c: 4b ff f9 a8 b ffc20714 <msdos_find_name_in_fat_file+0x350>
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
ffc20d70: 3b 7b 00 20 addi r27,r27,32
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
ffc20d74: 7f 99 d8 40 cmplw cr7,r25,r27
}
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
ffc20d78: 60 a0 00 40 ori r0,r5,64
ffc20d7c: 98 1c 00 00 stb r0,0(r28)
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
ffc20d80: 88 1c 00 0b lbz r0,11(r28)
ffc20d84: 60 00 00 0f ori r0,r0,15
ffc20d88: 98 1c 00 0b stb r0,11(r28)
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
ffc20d8c: 41 9d fe b4 bgt+ cr7,ffc20c40 <msdos_find_name_in_fat_file+0x87c><== ALWAYS TAKEN
ffc20d90: 7f 06 c3 78 mr r6,r24 <== NOT EXECUTED
ffc20d94: 7f 5b d3 78 mr r27,r26 <== NOT EXECUTED
ffc20d98: 4b ff ff 8c b ffc20d24 <msdos_find_name_in_fat_file+0x960><== NOT EXECUTED
* first entry written and if so remember the
* the location of the long file name.
*/
if (lfn_start.cln == FAT_FILE_SHORT_NAME)
{
lfn_start.cln = empty_space_offset;
ffc20d9c: 92 81 00 0c stw r20,12(r1)
lfn_start.ofs = dir_entry;
ffc20da0: 93 61 00 10 stw r27,16(r1)
ffc20da4: 4b ff fb fc b ffc209a0 <msdos_find_name_in_fat_file+0x5dc>
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
ffc20da8: 38 00 ff ff li r0,-1
ffc20dac: 4b ff ff 1c b ffc20cc8 <msdos_find_name_in_fat_file+0x904>
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
*c = '_';
ffc20db0: 81 41 00 18 lwz r10,24(r1) <== NOT EXECUTED
ffc20db4: 38 00 00 5f li r0,95 <== NOT EXECUTED
ffc20db8: 98 0a 00 01 stb r0,1(r10) <== NOT EXECUTED
ffc20dbc: 4b ff fe 08 b ffc20bc4 <msdos_find_name_in_fat_file+0x800><== NOT EXECUTED
ffc20dc0: 81 61 00 18 lwz r11,24(r1) <== NOT EXECUTED
ffc20dc4: 38 00 00 5f li r0,95 <== NOT EXECUTED
ffc20dc8: 98 0b 00 00 stb r0,0(r11) <== NOT EXECUTED
ffc20dcc: 4b ff fd e0 b ffc20bac <msdos_find_name_in_fat_file+0x7e8><== NOT EXECUTED
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
ffc20dd0: 7e fb bb 78 mr r27,r23
char* p;
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
ffc20dd4: 3b 00 00 20 li r24,32
ffc20dd8: 4b ff fe 8c b ffc20c64 <msdos_find_name_in_fat_file+0x8a0>
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
ffc20ddc: 38 c0 00 00 li r6,0 <== NOT EXECUTED
ffc20de0: 3b 00 00 00 li r24,0 <== NOT EXECUTED
ffc20de4: 4b ff ff 40 b ffc20d24 <msdos_find_name_in_fat_file+0x960><== NOT EXECUTED
ffc20de8: 2c 1a 00 00 cmpwi r26,0 <== NOT EXECUTED
ffc20dec: 4b ff fa a4 b ffc20890 <msdos_find_name_in_fat_file+0x4cc><== NOT EXECUTED
uint32_t empty_space_offset = 0;
uint32_t empty_space_entry = 0;
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
ffc20df0: 38 00 00 00 li r0,0
ffc20df4: 4b ff fb 28 b ffc2091c <msdos_find_name_in_fat_file+0x558>
#endif
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
ffc20df8: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
ffc20dfc: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc20e00: 38 a5 54 fc addi r5,r5,21756 <== NOT EXECUTED
ffc20e04: 3c c0 ff c3 lis r6,-61 <== NOT EXECUTED
ffc20e08: 38 63 55 74 addi r3,r3,21876 <== NOT EXECUTED
ffc20e0c: 38 80 04 49 li r4,1097 <== NOT EXECUTED
ffc20e10: 38 a5 00 14 addi r5,r5,20 <== NOT EXECUTED
ffc20e14: 38 c6 56 04 addi r6,r6,22020 <== NOT EXECUTED
ffc20e18: 4b fe 6e 79 bl ffc07c90 <__assert_func> <== NOT EXECUTED
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
assert(name_len > 0);
ffc20e1c: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
ffc20e20: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc20e24: 38 a5 54 fc addi r5,r5,21756 <== NOT EXECUTED
ffc20e28: 3c c0 ff c3 lis r6,-61 <== NOT EXECUTED
ffc20e2c: 38 63 55 74 addi r3,r3,21876 <== NOT EXECUTED
ffc20e30: 38 80 04 19 li r4,1049 <== NOT EXECUTED
ffc20e34: 38 a5 00 14 addi r5,r5,20 <== NOT EXECUTED
ffc20e38: 38 c6 55 f4 addi r6,r6,22004 <== NOT EXECUTED
ffc20e3c: 4b fe 6e 55 bl ffc07c90 <__assert_func> <== NOT EXECUTED
ffc20e40: 39 60 00 01 li r11,1 <== NOT EXECUTED
ffc20e44: 7d 69 03 a6 mtctr r11 <== NOT EXECUTED
ffc20e48: 4b ff f9 b8 b ffc20800 <msdos_find_name_in_fat_file+0x43c><== NOT EXECUTED
ffc20e4c <msdos_find_node_by_cluster_num_in_fat_file>:
fat_file_fd_t *fat_fd,
uint32_t cl4find,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
ffc20e4c: 94 21 ff d0 stwu r1,-48(r1) <== NOT EXECUTED
ffc20e50: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc20e54: 90 01 00 34 stw r0,52(r1) <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t bts2rd = 0;
uint32_t i = 0, j = 0;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
ffc20e58: 80 04 00 20 lwz r0,32(r4) <== NOT EXECUTED
fat_file_fd_t *fat_fd,
uint32_t cl4find,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
ffc20e5c: 92 c1 00 08 stw r22,8(r1) <== NOT EXECUTED
ffc20e60: 7c d6 33 78 mr r22,r6 <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t bts2rd = 0;
uint32_t i = 0, j = 0;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
ffc20e64: 2f 80 00 01 cmpwi cr7,r0,1 <== NOT EXECUTED
fat_file_fd_t *fat_fd,
uint32_t cl4find,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
ffc20e68: 92 e1 00 0c stw r23,12(r1) <== NOT EXECUTED
ffc20e6c: 7c f7 3b 78 mr r23,r7 <== NOT EXECUTED
ffc20e70: 93 01 00 10 stw r24,16(r1) <== NOT EXECUTED
ffc20e74: 7c 78 1b 78 mr r24,r3 <== NOT EXECUTED
ffc20e78: 93 41 00 18 stw r26,24(r1) <== NOT EXECUTED
ffc20e7c: 7c 9a 23 78 mr r26,r4 <== NOT EXECUTED
ffc20e80: 93 61 00 1c stw r27,28(r1) <== NOT EXECUTED
ffc20e84: 93 81 00 20 stw r28,32(r1) <== NOT EXECUTED
ffc20e88: 7c bc 2b 78 mr r28,r5 <== NOT EXECUTED
ffc20e8c: 93 21 00 14 stw r25,20(r1) <== NOT EXECUTED
ffc20e90: 93 a1 00 24 stw r29,36(r1) <== NOT EXECUTED
ffc20e94: 93 c1 00 28 stw r30,40(r1) <== NOT EXECUTED
ffc20e98: 93 e1 00 2c stw r31,44(r1) <== NOT EXECUTED
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
ffc20e9c: 83 63 00 34 lwz r27,52(r3) <== NOT EXECUTED
uint32_t bts2rd = 0;
uint32_t i = 0, j = 0;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
ffc20ea0: 41 9e 00 e0 beq- cr7,ffc20f80 <msdos_find_node_by_cluster_num_in_fat_file+0x134><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
ffc20ea4: a3 bb 00 06 lhz r29,6(r27) <== NOT EXECUTED
uint32_t bts2rd = 0;
uint32_t i = 0, j = 0;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
ffc20ea8: 80 fb 00 9c lwz r7,156(r27) <== NOT EXECUTED
fs_info->cl_buf)) != FAT_EOF)
{
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
rtems_set_errno_and_return_minus_one( EIO );
assert(ret == bts2rd);
ffc20eac: 3b 20 00 00 li r25,0 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
while ((ret = fat_file_read(mt_entry, fat_fd, j * bts2rd, bts2rd,
ffc20eb0: 7f 03 c3 78 mr r3,r24 <== NOT EXECUTED
ffc20eb4: 7f 44 d3 78 mr r4,r26 <== NOT EXECUTED
ffc20eb8: 7f 25 cb 78 mr r5,r25 <== NOT EXECUTED
ffc20ebc: 7f a6 eb 78 mr r6,r29 <== NOT EXECUTED
ffc20ec0: 4b ff 65 f9 bl ffc174b8 <fat_file_read> <== NOT EXECUTED
ffc20ec4: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc20ec8: 41 82 00 7c beq- ffc20f44 <msdos_find_node_by_cluster_num_in_fat_file+0xf8><== NOT EXECUTED
fs_info->cl_buf)) != FAT_EOF)
{
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
ffc20ecc: 2f 83 00 1f cmpwi cr7,r3,31 <== NOT EXECUTED
ffc20ed0: 40 9d 01 7c ble- cr7,ffc2104c <msdos_find_node_by_cluster_num_in_fat_file+0x200><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
assert(ret == bts2rd);
ffc20ed4: 7f 83 e8 00 cmpw cr7,r3,r29 <== NOT EXECUTED
ffc20ed8: 40 9e 01 88 bne- cr7,ffc21060 <msdos_find_node_by_cluster_num_in_fat_file+0x214><== NOT EXECUTED
ffc20edc: 80 fb 00 9c lwz r7,156(r27) <== NOT EXECUTED
ffc20ee0: 3b c0 00 00 li r30,0 <== NOT EXECUTED
ffc20ee4: 7c ff 3b 78 mr r31,r7 <== NOT EXECUTED
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
/* if this and all rest entries are empty - return not-found */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
ffc20ee8: 88 1f 00 00 lbz r0,0(r31) <== NOT EXECUTED
ffc20eec: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc20ef0: 41 9e 00 54 beq- cr7,ffc20f44 <msdos_find_node_by_cluster_num_in_fat_file+0xf8><== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
return MSDOS_NAME_NOT_FOUND_ERR;
/* if this entry is empty - skip it */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
ffc20ef4: 2f 80 00 e5 cmpwi cr7,r0,229 <== NOT EXECUTED
ffc20ef8: 41 9e 00 34 beq- cr7,ffc20f2c <msdos_find_node_by_cluster_num_in_fat_file+0xe0><== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
ffc20efc: a1 3f 00 14 lhz r9,20(r31) <== NOT EXECUTED
ffc20f00: a0 1f 00 1a lhz r0,26(r31) <== NOT EXECUTED
ffc20f04: 55 2b c2 3e rlwinm r11,r9,24,8,31 <== NOT EXECUTED
ffc20f08: 55 29 44 2e rlwinm r9,r9,8,16,23 <== NOT EXECUTED
ffc20f0c: 7d 69 4b 78 or r9,r11,r9 <== NOT EXECUTED
ffc20f10: 54 0b c2 3e rlwinm r11,r0,24,8,31 <== NOT EXECUTED
ffc20f14: 54 00 44 2e rlwinm r0,r0,8,16,23 <== NOT EXECUTED
ffc20f18: 55 29 80 1e rlwinm r9,r9,16,0,15 <== NOT EXECUTED
ffc20f1c: 7d 60 03 78 or r0,r11,r0 <== NOT EXECUTED
ffc20f20: 7d 20 03 78 or r0,r9,r0 <== NOT EXECUTED
ffc20f24: 7f 80 e0 00 cmpw cr7,r0,r28 <== NOT EXECUTED
ffc20f28: 41 9e 00 78 beq- cr7,ffc20fa0 <msdos_find_node_by_cluster_num_in_fat_file+0x154><== NOT EXECUTED
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
rtems_set_errno_and_return_minus_one( EIO );
assert(ret == bts2rd);
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
ffc20f2c: 3b de 00 20 addi r30,r30,32 <== NOT EXECUTED
ffc20f30: 7f 9e e8 40 cmplw cr7,r30,r29 <== NOT EXECUTED
ffc20f34: 3b ff 00 20 addi r31,r31,32 <== NOT EXECUTED
ffc20f38: 41 9c ff b0 blt+ cr7,ffc20ee8 <msdos_find_node_by_cluster_num_in_fat_file+0x9c><== NOT EXECUTED
ffc20f3c: 7f 39 ea 14 add r25,r25,r29 <== NOT EXECUTED
ffc20f40: 4b ff ff 70 b ffc20eb0 <msdos_find_node_by_cluster_num_in_fat_file+0x64><== NOT EXECUTED
char* entry = (char*) fs_info->cl_buf + i;
/* if this and all rest entries are empty - return not-found */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
return MSDOS_NAME_NOT_FOUND_ERR;
ffc20f44: 38 60 7d 01 li r3,32001 <== NOT EXECUTED
}
}
j++;
}
return MSDOS_NAME_NOT_FOUND_ERR;
}
ffc20f48: 80 01 00 34 lwz r0,52(r1) <== NOT EXECUTED
ffc20f4c: 82 c1 00 08 lwz r22,8(r1) <== NOT EXECUTED
ffc20f50: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc20f54: 82 e1 00 0c lwz r23,12(r1) <== NOT EXECUTED
ffc20f58: 83 01 00 10 lwz r24,16(r1) <== NOT EXECUTED
ffc20f5c: 83 21 00 14 lwz r25,20(r1) <== NOT EXECUTED
ffc20f60: 83 41 00 18 lwz r26,24(r1) <== NOT EXECUTED
ffc20f64: 83 61 00 1c lwz r27,28(r1) <== NOT EXECUTED
ffc20f68: 83 81 00 20 lwz r28,32(r1) <== NOT EXECUTED
ffc20f6c: 83 a1 00 24 lwz r29,36(r1) <== NOT EXECUTED
ffc20f70: 83 c1 00 28 lwz r30,40(r1) <== NOT EXECUTED
ffc20f74: 83 e1 00 2c lwz r31,44(r1) <== NOT EXECUTED
ffc20f78: 38 21 00 30 addi r1,r1,48 <== NOT EXECUTED
ffc20f7c: 4e 80 00 20 blr <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t bts2rd = 0;
uint32_t i = 0, j = 0;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
ffc20f80: 80 04 00 24 lwz r0,36(r4) <== NOT EXECUTED
ffc20f84: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc20f88: 40 be ff 1c bne- cr7,ffc20ea4 <msdos_find_node_by_cluster_num_in_fat_file+0x58><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
ffc20f8c: 88 1b 00 0a lbz r0,10(r27) <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t bts2rd = 0;
uint32_t i = 0, j = 0;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
ffc20f90: 70 09 00 03 andi. r9,r0,3 <== NOT EXECUTED
ffc20f94: 41 a2 ff 10 beq- ffc20ea4 <msdos_find_node_by_cluster_num_in_fat_file+0x58><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
ffc20f98: 83 a4 00 18 lwz r29,24(r4) <== NOT EXECUTED
ffc20f9c: 4b ff ff 0c b ffc20ea8 <msdos_find_node_by_cluster_num_in_fat_file+0x5c><== NOT EXECUTED
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
{
/* on success fill aux structure and copy all 32 bytes */
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM, j * bts2rd,
ffc20fa0: 7f 03 c3 78 mr r3,r24 <== NOT EXECUTED
ffc20fa4: 7f 44 d3 78 mr r4,r26 <== NOT EXECUTED
ffc20fa8: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc20fac: 7f 26 cb 78 mr r6,r25 <== NOT EXECUTED
ffc20fb0: 7e c7 b3 78 mr r7,r22 <== NOT EXECUTED
ffc20fb4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc20fb8: 4b ff 69 c5 bl ffc1797c <fat_file_ioctl> <== NOT EXECUTED
&dir_pos->sname.cln);
if (rc != RC_OK)
ffc20fbc: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc20fc0: 40 82 ff 88 bne+ ffc20f48 <msdos_find_node_by_cluster_num_in_fat_file+0xfc><== NOT EXECUTED
return rc;
dir_pos->sname.ofs = i;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
ffc20fc4: 38 00 ff ff li r0,-1 <== NOT EXECUTED
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM, j * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = i;
ffc20fc8: 93 d6 00 04 stw r30,4(r22) <== NOT EXECUTED
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
ffc20fcc: 90 16 00 08 stw r0,8(r22) <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
ffc20fd0: 90 16 00 0c stw r0,12(r22) <== NOT EXECUTED
memcpy(dir_entry, entry,
ffc20fd4: 81 5f 00 00 lwz r10,0(r31) <== NOT EXECUTED
ffc20fd8: 81 7f 00 04 lwz r11,4(r31) <== NOT EXECUTED
ffc20fdc: 81 3f 00 08 lwz r9,8(r31) <== NOT EXECUTED
ffc20fe0: 80 1f 00 0c lwz r0,12(r31) <== NOT EXECUTED
ffc20fe4: 91 57 00 00 stw r10,0(r23) <== NOT EXECUTED
ffc20fe8: 91 77 00 04 stw r11,4(r23) <== NOT EXECUTED
ffc20fec: 91 37 00 08 stw r9,8(r23) <== NOT EXECUTED
ffc20ff0: 90 17 00 0c stw r0,12(r23) <== NOT EXECUTED
ffc20ff4: 80 1f 00 1c lwz r0,28(r31) <== NOT EXECUTED
ffc20ff8: 81 5f 00 10 lwz r10,16(r31) <== NOT EXECUTED
ffc20ffc: 81 7f 00 14 lwz r11,20(r31) <== NOT EXECUTED
ffc21000: 81 3f 00 18 lwz r9,24(r31) <== NOT EXECUTED
ffc21004: 91 57 00 10 stw r10,16(r23) <== NOT EXECUTED
ffc21008: 91 77 00 14 stw r11,20(r23) <== NOT EXECUTED
ffc2100c: 91 37 00 18 stw r9,24(r23) <== NOT EXECUTED
ffc21010: 90 17 00 1c stw r0,28(r23) <== NOT EXECUTED
}
}
j++;
}
return MSDOS_NAME_NOT_FOUND_ERR;
}
ffc21014: 80 01 00 34 lwz r0,52(r1) <== NOT EXECUTED
ffc21018: 82 c1 00 08 lwz r22,8(r1) <== NOT EXECUTED
ffc2101c: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc21020: 82 e1 00 0c lwz r23,12(r1) <== NOT EXECUTED
ffc21024: 83 01 00 10 lwz r24,16(r1) <== NOT EXECUTED
ffc21028: 83 21 00 14 lwz r25,20(r1) <== NOT EXECUTED
ffc2102c: 83 41 00 18 lwz r26,24(r1) <== NOT EXECUTED
ffc21030: 83 61 00 1c lwz r27,28(r1) <== NOT EXECUTED
ffc21034: 83 81 00 20 lwz r28,32(r1) <== NOT EXECUTED
ffc21038: 83 a1 00 24 lwz r29,36(r1) <== NOT EXECUTED
ffc2103c: 83 c1 00 28 lwz r30,40(r1) <== NOT EXECUTED
ffc21040: 83 e1 00 2c lwz r31,44(r1) <== NOT EXECUTED
ffc21044: 38 21 00 30 addi r1,r1,48 <== NOT EXECUTED
ffc21048: 4e 80 00 20 blr <== NOT EXECUTED
while ((ret = fat_file_read(mt_entry, fat_fd, j * bts2rd, bts2rd,
fs_info->cl_buf)) != FAT_EOF)
{
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
rtems_set_errno_and_return_minus_one( EIO );
ffc2104c: 48 00 31 c5 bl ffc24210 <__errno> <== NOT EXECUTED
ffc21050: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc21054: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc21058: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc2105c: 4b ff fe ec b ffc20f48 <msdos_find_node_by_cluster_num_in_fat_file+0xfc><== NOT EXECUTED
assert(ret == bts2rd);
ffc21060: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
ffc21064: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc21068: 38 a5 54 fc addi r5,r5,21756 <== NOT EXECUTED
ffc2106c: 3c c0 ff c3 lis r6,-61 <== NOT EXECUTED
ffc21070: 38 63 55 74 addi r3,r3,21876 <== NOT EXECUTED
ffc21074: 38 80 06 9e li r4,1694 <== NOT EXECUTED
ffc21078: 38 a5 00 30 addi r5,r5,48 <== NOT EXECUTED
ffc2107c: 38 c6 56 04 addi r6,r6,22020 <== NOT EXECUTED
ffc21080: 4b fe 6c 11 bl ffc07c90 <__assert_func> <== NOT EXECUTED
ffc12680 <msdos_format>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
ffc12680: 94 21 fd 10 stwu r1,-752(r1)
ffc12684: 7d 80 00 26 mfcr r12
ffc12688: 7c 08 02 a6 mflr r0
msdos_format_param_t fmt_params;
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
ffc1268c: 3c a0 ff c3 lis r5,-61
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
ffc12690: 93 e1 02 ec stw r31,748(r1)
ffc12694: 7c 9f 23 78 mr r31,r4
msdos_format_param_t fmt_params;
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
ffc12698: 38 a5 4e cc addi r5,r5,20172
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
ffc1269c: 93 a1 02 e4 stw r29,740(r1)
msdos_format_param_t fmt_params;
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
ffc126a0: 38 80 00 02 li r4,2
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
ffc126a4: 7c 7d 1b 78 mr r29,r3
msdos_format_param_t fmt_params;
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
ffc126a8: 7f e3 fb 78 mr r3,r31
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
ffc126ac: 90 01 02 f4 stw r0,756(r1)
ffc126b0: 93 c1 02 e8 stw r30,744(r1)
ffc126b4: 91 81 02 c4 stw r12,708(r1)
ffc126b8: 92 c1 02 c8 stw r22,712(r1)
ffc126bc: 92 e1 02 cc stw r23,716(r1)
ffc126c0: 93 01 02 d0 stw r24,720(r1)
ffc126c4: 93 21 02 d4 stw r25,724(r1)
ffc126c8: 93 41 02 d8 stw r26,728(r1)
ffc126cc: 93 61 02 dc stw r27,732(r1)
ffc126d0: 93 81 02 e0 stw r28,736(r1)
msdos_format_param_t fmt_params;
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
ffc126d4: 4c c6 31 82 crclr 4*cr1+eq
ffc126d8: 4b ff fc 51 bl ffc12328 <msdos_format_printf>
fd = open(devname, O_RDWR);
ffc126dc: 7f a3 eb 78 mr r3,r29
ffc126e0: 38 80 00 02 li r4,2
ffc126e4: 4c c6 31 82 crclr 4*cr1+eq
ffc126e8: 4b ff 71 7d bl ffc09864 <open>
if (fd == -1) {
ffc126ec: 2e 03 ff ff cmpwi cr4,r3,-1
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
fd = open(devname, O_RDWR);
ffc126f0: 7c 7e 1b 78 mr r30,r3
if (fd == -1) {
ffc126f4: 41 92 01 d4 beq- cr4,ffc128c8 <msdos_format+0x248> <== NEVER TAKEN
}
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc126f8: 3c a0 ff c3 lis r5,-61
ffc126fc: 38 a5 4e dc addi r5,r5,20188
ffc12700: 7f a6 eb 78 mr r6,r29
ffc12704: 38 80 00 02 li r4,2
ffc12708: 7f e3 fb 78 mr r3,r31
ffc1270c: 4c c6 31 82 crclr 4*cr1+eq
ffc12710: 4b ff fc 19 bl ffc12328 <msdos_format_printf>
"stat check: %s\n", devname);
if (ret_val == 0) {
rc = fstat(fd, &stat_buf);
ffc12714: 38 81 00 18 addi r4,r1,24
ffc12718: 7f c3 f3 78 mr r3,r30
ffc1271c: 48 00 84 c5 bl ffc1abe0 <fstat>
ret_val = rc;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
ffc12720: 3c a0 ff c3 lis r5,-61
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"stat check: %s\n", devname);
if (ret_val == 0) {
rc = fstat(fd, &stat_buf);
ffc12724: 7c 7c 1b 78 mr r28,r3
ret_val = rc;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
ffc12728: 38 80 00 01 li r4,1
ffc1272c: 7f e3 fb 78 mr r3,r31
ffc12730: 38 a5 4e ec addi r5,r5,20204
ffc12734: 7f a6 eb 78 mr r6,r29
ffc12738: 4c c6 31 82 crclr 4*cr1+eq
ffc1273c: 4b ff fb ed bl ffc12328 <msdos_format_printf>
"formating: %s\n", devname);
/* rtems feature: no block devices, all are character devices */
if ((ret_val == 0) && (!S_ISBLK(stat_buf.st_mode))) {
ffc12740: 2f 9c 00 00 cmpwi cr7,r28,0
ffc12744: 40 9e 0d 34 bne- cr7,ffc13478 <msdos_format+0xdf8> <== NEVER TAKEN
ffc12748: 80 01 00 24 lwz r0,36(r1)
ffc1274c: 54 00 04 26 rlwinm r0,r0,0,16,19
ffc12750: 2f 80 60 00 cmpwi cr7,r0,24576
ffc12754: 41 9e 00 70 beq- cr7,ffc127c4 <msdos_format+0x144> <== ALWAYS TAKEN
/* check that device is registered as block device and lock it */
if (ret_val == 0) {
dd = rtems_disk_obtain(stat_buf.st_rdev);
if (dd == NULL) {
errno = ENOTTY;
ffc12758: 48 01 1a b9 bl ffc24210 <__errno> <== NOT EXECUTED
ffc1275c: 38 00 00 19 li r0,25 <== NOT EXECUTED
ffc12760: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ret_val = -1;
ffc12764: 3b 00 ff ff li r24,-1 <== NOT EXECUTED
* mark this in every copy of the FAT
*/
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
}
for (i = 0;
(i < fmt_params.fat_num) && (ret_val == 0);
ffc12768: 3b a0 00 00 li r29,0 <== NOT EXECUTED
ffc1276c: 2d 9d 00 00 cmpwi cr3,r29,0 <== NOT EXECUTED
/*
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
ffc12770: 40 92 01 4c bne- cr4,ffc128bc <msdos_format+0x23c> <== NOT EXECUTED
close(fd);
}
if (dd != NULL) {
ffc12774: 41 8e 00 0c beq- cr3,ffc12780 <msdos_format+0x100> <== NEVER TAKEN
rtems_disk_release(dd);
ffc12778: 7f a3 eb 78 mr r3,r29
ffc1277c: 4b ff 49 49 bl ffc070c4 <rtems_disk_release>
}
return ret_val;
}
ffc12780: 80 01 02 f4 lwz r0,756(r1)
ffc12784: 7f 03 c3 78 mr r3,r24
ffc12788: 81 81 02 c4 lwz r12,708(r1)
ffc1278c: 7c 08 03 a6 mtlr r0
ffc12790: 82 c1 02 c8 lwz r22,712(r1)
ffc12794: 82 e1 02 cc lwz r23,716(r1)
ffc12798: 7d 83 81 20 mtcrf 56,r12
ffc1279c: 83 01 02 d0 lwz r24,720(r1)
ffc127a0: 83 21 02 d4 lwz r25,724(r1)
ffc127a4: 83 41 02 d8 lwz r26,728(r1)
ffc127a8: 83 61 02 dc lwz r27,732(r1)
ffc127ac: 83 81 02 e0 lwz r28,736(r1)
ffc127b0: 83 a1 02 e4 lwz r29,740(r1)
ffc127b4: 83 c1 02 e8 lwz r30,744(r1)
ffc127b8: 83 e1 02 ec lwz r31,748(r1)
ffc127bc: 38 21 02 f0 addi r1,r1,752
ffc127c0: 4e 80 00 20 blr
ret_val = -1;
}
/* check that device is registered as block device and lock it */
if (ret_val == 0) {
dd = rtems_disk_obtain(stat_buf.st_rdev);
ffc127c4: 80 61 00 30 lwz r3,48(r1)
ffc127c8: 80 81 00 34 lwz r4,52(r1)
ffc127cc: 4b ff 48 45 bl ffc07010 <rtems_disk_obtain>
if (dd == NULL) {
ffc127d0: 2d 83 00 00 cmpwi cr3,r3,0
ffc127d4: 7c 7d 1b 78 mr r29,r3
ffc127d8: 41 ae ff 80 beq- cr3,ffc12758 <msdos_format+0xd8> <== NEVER TAKEN
uint32_t fatdata_sect_cnt;
uint32_t onebit;
uint32_t sectors_per_cluster_adj = 0;
uint64_t total_size = 0;
memset(fmt_params,0,sizeof(*fmt_params));
ffc127dc: 38 80 00 00 li r4,0
ffc127e0: 38 a0 00 50 li r5,80
ffc127e4: 38 61 00 60 addi r3,r1,96
ffc127e8: 48 01 29 41 bl ffc25128 <memset>
* this one is fixed in this implementation.
* At least one thing we don't have to magically guess...
*/
if (ret_val == 0) {
fmt_params->bytes_per_sector = dd->block_size;
fmt_params->totl_sector_cnt = dd->size;
ffc127ec: 83 9d 00 1c lwz r28,28(r29)
/*
* this one is fixed in this implementation.
* At least one thing we don't have to magically guess...
*/
if (ret_val == 0) {
fmt_params->bytes_per_sector = dd->block_size;
ffc127f0: 80 dd 00 20 lwz r6,32(r29)
}
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
ffc127f4: 2d 1f 00 00 cmpwi cr2,r31,0
*/
if (ret_val == 0) {
fmt_params->bytes_per_sector = dd->block_size;
fmt_params->totl_sector_cnt = dd->size;
total_size = dd->block_size * dd->size;
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc127f8: 3c a0 ff c3 lis r5,-61
* this one is fixed in this implementation.
* At least one thing we don't have to magically guess...
*/
if (ret_val == 0) {
fmt_params->bytes_per_sector = dd->block_size;
fmt_params->totl_sector_cnt = dd->size;
ffc127fc: 93 81 00 64 stw r28,100(r1)
total_size = dd->block_size * dd->size;
ffc12800: 7f 7c 31 d6 mullw r27,r28,r6
/*
* this one is fixed in this implementation.
* At least one thing we don't have to magically guess...
*/
if (ret_val == 0) {
fmt_params->bytes_per_sector = dd->block_size;
ffc12804: 90 c1 00 60 stw r6,96(r1)
fmt_params->totl_sector_cnt = dd->size;
total_size = dd->block_size * dd->size;
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc12808: 7f e3 fb 78 mr r3,r31
ffc1280c: 38 80 00 02 li r4,2
ffc12810: 38 a5 4f 7c addi r5,r5,20348
ffc12814: 7f 87 e3 78 mr r7,r28
ffc12818: 39 20 00 00 li r9,0
ffc1281c: 7f 6a db 78 mr r10,r27
ffc12820: 4c c6 31 82 crclr 4*cr1+eq
ffc12824: 4b ff fb 05 bl ffc12328 <msdos_format_printf>
}
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
ffc12828: 41 8a 09 f8 beq- cr2,ffc13220 <msdos_format+0xba0> <== NEVER TAKEN
(rqdata->fat_num == 0)) {
ffc1282c: 80 1f 00 0c lwz r0,12(r31)
}
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
ffc12830: 2f 80 00 00 cmpwi cr7,r0,0
ffc12834: 41 9e 00 d4 beq- cr7,ffc12908 <msdos_format+0x288> <== ALWAYS TAKEN
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
}
else if (rqdata->fat_num <= 6) {
ffc12838: 2b 80 00 06 cmplwi cr7,r0,6 <== NOT EXECUTED
ffc1283c: 41 9d 02 ac bgt- cr7,ffc12ae8 <msdos_format+0x468> <== NOT EXECUTED
fmt_params->fat_num = rqdata->fat_num;
ffc12840: 54 00 06 3e clrlwi r0,r0,24 <== NOT EXECUTED
ret_val = EINVAL;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc12844: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
if ((rqdata == NULL) ||
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
}
else if (rqdata->fat_num <= 6) {
fmt_params->fat_num = rqdata->fat_num;
ffc12848: 98 01 00 90 stb r0,144(r1) <== NOT EXECUTED
ret_val = EINVAL;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc1284c: 7c 06 03 78 mr r6,r0 <== NOT EXECUTED
ffc12850: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc12854: 38 80 00 02 li r4,2 <== NOT EXECUTED
ffc12858: 38 a5 4e fc addi r5,r5,20220 <== NOT EXECUTED
ffc1285c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc12860: 4b ff fa c9 bl ffc12328 <msdos_format_printf> <== NOT EXECUTED
/*
* determine FAT type and sectors per cluster
* depends on
*/
if (ret_val == 0) {
fmt_params->sectors_per_cluster = 1;
ffc12864: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc12868: 90 01 00 6c stw r0,108(r1) <== NOT EXECUTED
if ((rqdata != NULL) &&
(rqdata->fattype == MSDOS_FMT_FAT12)) {
ffc1286c: 88 1f 00 14 lbz r0,20(r31)
* determine FAT type and sectors per cluster
* depends on
*/
if (ret_val == 0) {
fmt_params->sectors_per_cluster = 1;
if ((rqdata != NULL) &&
ffc12870: 2f 80 00 01 cmpwi cr7,r0,1
ffc12874: 41 9e 00 c8 beq- cr7,ffc1293c <msdos_format+0x2bc> <== NEVER TAKEN
(rqdata->fattype == MSDOS_FMT_FAT12)) {
fmt_params->fattype = FAT_FAT12;
}
else if ((rqdata != NULL) &&
ffc12878: 2f 80 00 02 cmpwi cr7,r0,2
ffc1287c: 41 9e 00 c0 beq- cr7,ffc1293c <msdos_format+0x2bc> <== NEVER TAKEN
(rqdata->fattype == MSDOS_FMT_FAT16)) {
fmt_params->fattype = FAT_FAT16;
}
else if ((rqdata != NULL) &&
ffc12880: 2f 80 00 03 cmpwi cr7,r0,3
ffc12884: 41 9e 00 b4 beq- cr7,ffc12938 <msdos_format+0x2b8> <== NEVER TAKEN
(rqdata->fattype == MSDOS_FMT_FAT32)) {
fmt_params->fattype = FAT_FAT32;
}
else if ((rqdata != NULL) &&
ffc12888: 2f 80 00 00 cmpwi cr7,r0,0
ffc1288c: 83 81 00 64 lwz r28,100(r1)
ffc12890: 40 9e 07 a8 bne- cr7,ffc13038 <msdos_format+0x9b8> <== NEVER TAKEN
/*
* limiting values for disk size, fat type, sectors per cluster
* NOTE: maximum sect_per_clust is arbitrarily choosen with values that
* are a compromise concerning capacity and efficency
*/
if (fmt_params->totl_sector_cnt
ffc12894: 2b 9c 7f a7 cmplwi cr7,r28,32679
ffc12898: 41 9d 0a 60 bgt- cr7,ffc132f8 <msdos_format+0xc78> <== NEVER TAKEN
< ((uint32_t)FAT_FAT12_MAX_CLN)*8) {
fmt_params->fattype = FAT_FAT12;
ffc1289c: 38 00 00 01 li r0,1
ffc128a0: 98 01 00 92 stb r0,146(r1)
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
ffc128a4: 38 00 00 02 li r0,2
ffc128a8: 90 01 00 6c stw r0,108(r1)
}
}
/*
* try to use user requested cluster size
*/
if ((rqdata != NULL) &&
ffc128ac: 41 8a 0b 18 beq- cr2,ffc133c4 <msdos_format+0xd44> <== NEVER TAKEN
ffc128b0: 3b 60 00 00 li r27,0
ffc128b4: 48 00 00 90 b ffc12944 <msdos_format+0x2c4>
* mark this in every copy of the FAT
*/
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
}
for (i = 0;
(i < fmt_params.fat_num) && (ret_val == 0);
ffc128b8: 3b 00 ff ff li r24,-1 <== NOT EXECUTED
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
close(fd);
ffc128bc: 7f c3 f3 78 mr r3,r30
ffc128c0: 4b ff 57 c9 bl ffc08088 <close>
ffc128c4: 4b ff fe b0 b ffc12774 <msdos_format+0xf4>
}
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc128c8: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
ffc128cc: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc128d0: 38 80 00 02 li r4,2 <== NOT EXECUTED
ffc128d4: 38 a5 4e dc addi r5,r5,20188 <== NOT EXECUTED
ffc128d8: 7f a6 eb 78 mr r6,r29 <== NOT EXECUTED
ffc128dc: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc128e0: 4b ff fa 49 bl ffc12328 <msdos_format_printf> <== NOT EXECUTED
if (ret_val == 0) {
rc = fstat(fd, &stat_buf);
ret_val = rc;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
ffc128e4: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
ffc128e8: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc128ec: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc128f0: 38 a5 4e ec addi r5,r5,20204 <== NOT EXECUTED
ffc128f4: 7f a6 eb 78 mr r6,r29 <== NOT EXECUTED
ffc128f8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc128fc: 4b ff fa 2d bl ffc12328 <msdos_format_printf> <== NOT EXECUTED
ffc12900: 3b 00 ff ff li r24,-1 <== NOT EXECUTED
ffc12904: 4b ff fe 64 b ffc12768 <msdos_format+0xe8> <== NOT EXECUTED
ret_val = EINVAL;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc12908: 3c a0 ff c3 lis r5,-61
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
ffc1290c: 38 00 00 02 li r0,2
ret_val = EINVAL;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc12910: 7f e3 fb 78 mr r3,r31
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
ffc12914: 98 01 00 90 stb r0,144(r1)
ret_val = EINVAL;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc12918: 38 80 00 02 li r4,2
ffc1291c: 38 a5 4e fc addi r5,r5,20220
ffc12920: 38 c0 00 02 li r6,2
ffc12924: 4c c6 31 82 crclr 4*cr1+eq
ffc12928: 4b ff fa 01 bl ffc12328 <msdos_format_printf>
/*
* determine FAT type and sectors per cluster
* depends on
*/
if (ret_val == 0) {
fmt_params->sectors_per_cluster = 1;
ffc1292c: 38 00 00 01 li r0,1
ffc12930: 90 01 00 6c stw r0,108(r1)
ffc12934: 4b ff ff 38 b ffc1286c <msdos_format+0x1ec>
(rqdata->fattype == MSDOS_FMT_FAT16)) {
fmt_params->fattype = FAT_FAT16;
}
else if ((rqdata != NULL) &&
(rqdata->fattype == MSDOS_FMT_FAT32)) {
fmt_params->fattype = FAT_FAT32;
ffc12938: 38 00 00 04 li r0,4 <== NOT EXECUTED
ffc1293c: 98 01 00 92 stb r0,146(r1) <== NOT EXECUTED
ffc12940: 3b 60 00 00 li r27,0 <== NOT EXECUTED
}
/*
* try to use user requested cluster size
*/
if ((rqdata != NULL) &&
(rqdata->sectors_per_cluster > 0)) {
ffc12944: 81 3f 00 08 lwz r9,8(r31)
}
}
/*
* try to use user requested cluster size
*/
if ((rqdata != NULL) &&
ffc12948: 2f 89 00 00 cmpwi cr7,r9,0
ffc1294c: 7d 2b 4b 78 mr r11,r9
ffc12950: 40 9e 00 0c bne- cr7,ffc1295c <msdos_format+0x2dc> <== NEVER TAKEN
ffc12954: 81 61 00 6c lwz r11,108(r1)
ffc12958: 7d 69 5b 78 mr r9,r11
*/
for (onebit = 128;onebit >= 1;onebit = onebit>>1) {
if (fmt_params->sectors_per_cluster >= onebit) {
fmt_params->sectors_per_cluster = onebit;
if (fmt_params->sectors_per_cluster
<= 32768L/fmt_params->bytes_per_sector) {
ffc1295c: 38 e0 00 08 li r7,8
ffc12960: 81 01 00 60 lwz r8,96(r1)
ffc12964: 7c e9 03 a6 mtctr r7
ffc12968: 39 40 00 00 li r10,0
ffc1296c: 38 00 00 80 li r0,128
ffc12970: 61 4a 80 00 ori r10,r10,32768
* must be power of 2
* must be smaller than or equal to 128
* sectors_per_cluster*bytes_per_sector must not be bigger than 32K
*/
for (onebit = 128;onebit >= 1;onebit = onebit>>1) {
if (fmt_params->sectors_per_cluster >= onebit) {
ffc12974: 7f 80 48 40 cmplw cr7,r0,r9
ffc12978: 41 9d 01 60 bgt- cr7,ffc12ad8 <msdos_format+0x458>
fmt_params->sectors_per_cluster = onebit;
if (fmt_params->sectors_per_cluster
<= 32768L/fmt_params->bytes_per_sector) {
ffc1297c: 7d 2a 43 96 divwu r9,r10,r8
* sectors_per_cluster*bytes_per_sector must not be bigger than 32K
*/
for (onebit = 128;onebit >= 1;onebit = onebit>>1) {
if (fmt_params->sectors_per_cluster >= onebit) {
fmt_params->sectors_per_cluster = onebit;
if (fmt_params->sectors_per_cluster
ffc12980: 7f 89 00 40 cmplw cr7,r9,r0
ffc12984: 7c 0b 03 78 mr r11,r0
ffc12988: 41 9c 01 50 blt- cr7,ffc12ad8 <msdos_format+0x458> <== NEVER TAKEN
ffc1298c: 90 01 00 6c stw r0,108(r1)
}
}
}
}
if (ret_val == 0) {
ffc12990: 2f 9b 00 00 cmpwi cr7,r27,0
ffc12994: 7d 00 00 26 mfcr r8
ffc12998: 55 08 e0 06 rlwinm r8,r8,28,0,3
ffc1299c: 91 01 02 b8 stw r8,696(r1)
ffc129a0: 40 9e 06 34 bne- cr7,ffc12fd4 <msdos_format+0x954> <== NEVER TAKEN
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc129a4: 83 81 00 6c lwz r28,108(r1)
ffc129a8: 3c a0 ff c3 lis r5,-61
ffc129ac: 7f e3 fb 78 mr r3,r31
ffc129b0: 38 80 00 02 li r4,2
ffc129b4: 38 a5 4f 10 addi r5,r5,20240
ffc129b8: 7f 86 e3 78 mr r6,r28
ffc129bc: 4c c6 31 82 crclr 4*cr1+eq
ffc129c0: 4b ff f9 69 bl ffc12328 <msdos_format_printf>
"sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
if (fmt_params->fattype == FAT_FAT32) {
ffc129c4: 89 61 00 92 lbz r11,146(r1)
ffc129c8: 2f 8b 00 04 cmpwi cr7,r11,4
ffc129cc: 41 9e 09 cc beq- cr7,ffc13398 <msdos_format+0xd18> <== NEVER TAKEN
fmt_params->fsinfo_sec = 1;
}
else {
/* recommended: for FAT12/FAT16, always set reserved sector count to 1 */
fmt_params->rsvd_sector_cnt = 1;
ffc129d0: 38 00 00 01 li r0,1
ffc129d4: 90 01 00 68 stw r0,104(r1)
/* recommended: for FAT16, set files per root directory to 512 */
/* for FAT12/FAT16, set files per root directory */
/* must fill up an even count of sectors */
if ((rqdata != NULL) &&
ffc129d8: 41 8a 00 10 beq- cr2,ffc129e8 <msdos_format+0x368> <== NEVER TAKEN
(rqdata->files_per_root_dir > 0)) {
ffc129dc: 81 5f 00 10 lwz r10,16(r31)
/* recommended: for FAT12/FAT16, always set reserved sector count to 1 */
fmt_params->rsvd_sector_cnt = 1;
/* recommended: for FAT16, set files per root directory to 512 */
/* for FAT12/FAT16, set files per root directory */
/* must fill up an even count of sectors */
if ((rqdata != NULL) &&
ffc129e0: 2f 8a 00 00 cmpwi cr7,r10,0
ffc129e4: 40 9e 06 4c bne- cr7,ffc13030 <msdos_format+0x9b0> <== NEVER TAKEN
(rqdata->files_per_root_dir > 0)) {
fmt_params->files_per_root_dir = rqdata->files_per_root_dir;
}
else {
if (fmt_params->fattype == FAT_FAT16) {
ffc129e8: 69 6a 00 02 xori r10,r11,2
ffc129ec: 31 4a ff ff addic r10,r10,-1
ffc129f0: 7d 4a 51 10 subfe r10,r10,r10
ffc129f4: 55 4a 05 f2 rlwinm r10,r10,0,23,25
ffc129f8: 39 4a 00 3f addi r10,r10,63
else {
fmt_params->files_per_root_dir = 64;
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
(2*fmt_params->bytes_per_sector/
ffc129fc: 81 21 00 60 lwz r9,96(r1)
FAT_DIRENTRY_SIZE-1));
fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
ffc12a00: 38 c0 00 01 li r6,1
else {
fmt_params->files_per_root_dir = 64;
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
(2*fmt_params->bytes_per_sector/
ffc12a04: 55 20 e1 7e rlwinm r0,r9,28,5,31
}
else {
fmt_params->files_per_root_dir = 64;
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
ffc12a08: 7d 4a 02 14 add r10,r10,r0
(2*fmt_params->bytes_per_sector/
FAT_DIRENTRY_SIZE-1));
fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
ffc12a0c: 7d 4a 03 96 divwu r10,r10,r0
ffc12a10: 7c 0a 01 d6 mullw r0,r10,r0
ffc12a14: 90 01 00 78 stw r0,120(r1)
ffc12a18: 54 07 28 34 rlwinm r7,r0,5,0,26
uint32_t sectors_per_fat;
uint32_t data_cluster_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
ffc12a1c: 38 00 00 00 li r0,0
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
+ fmt_params->bytes_per_sector - 1)
/ fmt_params->bytes_per_sector);
}
if (ret_val == 0) {
fatdata_sect_cnt = (fmt_params->totl_sector_cnt -
ffc12a20: 81 01 00 64 lwz r8,100(r1)
uint32_t sectors_per_fat;
uint32_t data_cluster_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
ffc12a24: 60 00 80 00 ori r0,r0,32768
/*
* check values to get legal arrangement of FAT type and cluster count
*/
ret_val = msdos_format_eval_sectors_per_cluster
(fmt_params->fattype,
ffc12a28: 8b 21 00 90 lbz r25,144(r1)
uint32_t sectors_per_fat;
uint32_t data_cluster_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
ffc12a2c: 7c 00 4b 96 divwu r0,r0,r9
(2*fmt_params->bytes_per_sector
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
+ fmt_params->bytes_per_sector - 1)
ffc12a30: 39 49 ff ff addi r10,r9,-1
ffc12a34: 7c ea 3a 14 add r7,r10,r7
/ fmt_params->bytes_per_sector);
ffc12a38: 7c e7 4b 96 divwu r7,r7,r9
uint32_t sectors_per_fat;
uint32_t data_cluster_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
ffc12a3c: 7f 9c 00 40 cmplw cr7,r28,r0
FAT_DIRENTRY_SIZE-1));
fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
(2*fmt_params->bytes_per_sector
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
ffc12a40: 90 e1 00 7c stw r7,124(r1)
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
+ fmt_params->bytes_per_sector - 1)
/ fmt_params->bytes_per_sector);
}
if (ret_val == 0) {
fatdata_sect_cnt = (fmt_params->totl_sector_cnt -
ffc12a44: 7d 06 40 50 subf r8,r6,r8
ffc12a48: 7d 07 40 50 subf r8,r7,r8
/*
* check values to get legal arrangement of FAT type and cluster count
*/
ret_val = msdos_format_eval_sectors_per_cluster
(fmt_params->fattype,
ffc12a4c: 57 27 06 3e clrlwi r7,r25,24
uint32_t sectors_per_fat;
uint32_t data_cluster_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
ffc12a50: 40 9d 00 10 ble- cr7,ffc12a60 <msdos_format+0x3e0> <== ALWAYS TAKEN
sectors_per_cluster /= 2;
ffc12a54: 57 9c f8 7e rlwinm r28,r28,31,1,31 <== NOT EXECUTED
uint32_t sectors_per_fat;
uint32_t data_cluster_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
ffc12a58: 7f 9c 00 40 cmplw cr7,r28,r0 <== NOT EXECUTED
ffc12a5c: 41 9d ff f8 bgt+ cr7,ffc12a54 <msdos_format+0x3d4> <== NOT EXECUTED
ffc12a60: 2c 0b 00 01 cmpwi r11,1
*/
fatdata_cluster_cnt = fatdata_sec_cnt/sectors_per_cluster;
if (fattype == FAT_FAT12) {
fat_capacity = fatdata_cluster_cnt * 3 / 2;
}
else if (fattype == FAT_FAT16) {
ffc12a64: 2c 8b 00 02 cmpwi cr1,r11,2
* compute number of data clusters for current data:
* - compute cluster count for data AND fat
* - compute storage size for FAT
* - subtract from total cluster count
*/
fatdata_cluster_cnt = fatdata_sec_cnt/sectors_per_cluster;
ffc12a68: 7c 08 e3 96 divwu r0,r8,r28
if (fattype == FAT_FAT12) {
ffc12a6c: 41 82 06 50 beq- ffc130bc <msdos_format+0xa3c> <== ALWAYS TAKEN
fat_capacity = fatdata_cluster_cnt * 3 / 2;
}
else if (fattype == FAT_FAT16) {
ffc12a70: 41 86 06 88 beq- cr1,ffc130f8 <msdos_format+0xa78> <== NOT EXECUTED
fat_capacity = fatdata_cluster_cnt * 2;
}
else { /* FAT32 */
fat_capacity = fatdata_cluster_cnt * 4;
ffc12a74: 54 1a 10 3a rlwinm r26,r0,2,0,29 <== NOT EXECUTED
}
sectors_per_fat = ((fat_capacity
+ (bytes_per_sector - 1))
ffc12a78: 7f 4a d2 14 add r26,r10,r26 <== NOT EXECUTED
}
else { /* FAT32 */
fat_capacity = fatdata_cluster_cnt * 4;
}
sectors_per_fat = ((fat_capacity
ffc12a7c: 7f 5a 4b 96 divwu r26,r26,r9 <== NOT EXECUTED
if (((fattype == FAT_FAT12) && (data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
((fattype == FAT_FAT16) && (data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
sectors_per_cluster *= 2;
}
else {
finished = true;
ffc12a80: 39 60 00 01 li r11,1 <== NOT EXECUTED
}
/*
* when maximum cluster size is exceeded, we have invalid data, abort...
*/
if ((sectors_per_cluster * bytes_per_sector)
ffc12a84: 7c 1c 49 d6 mullw r0,r28,r9
> MS_BYTES_PER_CLUSTER_LIMIT) {
ret_val = EINVAL;
finished = true;
}
} while (!finished);
ffc12a88: 2f 0b 00 00 cmpwi cr6,r11,0
finished = true;
}
/*
* when maximum cluster size is exceeded, we have invalid data, abort...
*/
if ((sectors_per_cluster * bytes_per_sector)
ffc12a8c: 2b 80 80 00 cmplwi cr7,r0,32768
ffc12a90: 40 9d 05 bc ble- cr7,ffc1304c <msdos_format+0x9cc> <== ALWAYS TAKEN
finished = true;
}
} while (!finished);
if (ret_val != 0) {
rtems_set_errno_and_return_minus_one(ret_val);
ffc12a94: 48 01 17 7d bl ffc24210 <__errno> <== NOT EXECUTED
fatdata_sect_cnt,
fmt_params->fat_num,
fmt_params->sectors_per_cluster,
§ors_per_cluster_adj,
&(fmt_params->sectors_per_fat));
fmt_params->sectors_per_cluster = sectors_per_cluster_adj;
ffc12a98: 3b 60 ff ff li r27,-1 <== NOT EXECUTED
ffc12a9c: 80 01 00 70 lwz r0,112(r1) <== NOT EXECUTED
ffc12aa0: 2f 9b 00 00 cmpwi cr7,r27,0 <== NOT EXECUTED
ffc12aa4: 89 21 00 90 lbz r9,144(r1) <== NOT EXECUTED
finished = true;
}
} while (!finished);
if (ret_val != 0) {
rtems_set_errno_and_return_minus_one(ret_val);
ffc12aa8: 39 60 00 16 li r11,22 <== NOT EXECUTED
ffc12aac: 91 63 00 00 stw r11,0(r3) <== NOT EXECUTED
fatdata_sect_cnt,
fmt_params->fat_num,
fmt_params->sectors_per_cluster,
§ors_per_cluster_adj,
&(fmt_params->sectors_per_fat));
fmt_params->sectors_per_cluster = sectors_per_cluster_adj;
ffc12ab0: 7d 29 01 d6 mullw r9,r9,r0 <== NOT EXECUTED
ffc12ab4: 7c a0 00 26 mfcr r5 <== NOT EXECUTED
ffc12ab8: 54 a5 e0 06 rlwinm r5,r5,28,0,3 <== NOT EXECUTED
ffc12abc: 81 61 00 68 lwz r11,104(r1) <== NOT EXECUTED
ffc12ac0: 80 01 00 7c lwz r0,124(r1) <== NOT EXECUTED
ffc12ac4: 7d 29 5a 14 add r9,r9,r11 <== NOT EXECUTED
ffc12ac8: 90 a1 02 b8 stw r5,696(r1) <== NOT EXECUTED
ffc12acc: 39 60 00 00 li r11,0 <== NOT EXECUTED
ffc12ad0: 91 61 00 6c stw r11,108(r1) <== NOT EXECUTED
ffc12ad4: 48 00 05 2c b ffc13000 <msdos_format+0x980> <== NOT EXECUTED
* check sectors per cluster.
* must be power of 2
* must be smaller than or equal to 128
* sectors_per_cluster*bytes_per_sector must not be bigger than 32K
*/
for (onebit = 128;onebit >= 1;onebit = onebit>>1) {
ffc12ad8: 54 00 f8 7e rlwinm r0,r0,31,1,31
ffc12adc: 42 40 09 a4 bdz- ffc13480 <msdos_format+0xe00>
ffc12ae0: 7d 69 5b 78 mr r9,r11
ffc12ae4: 4b ff fe 90 b ffc12974 <msdos_format+0x2f4>
}
else if (rqdata->fat_num <= 6) {
fmt_params->fat_num = rqdata->fat_num;
}
else {
ret_val = EINVAL;
ffc12ae8: 3b 60 00 16 li r27,22 <== NOT EXECUTED
ffc12aec: 2f 9b 00 00 cmpwi cr7,r27,0 <== NOT EXECUTED
if (ret_val == 0) {
if ((rqdata == NULL) ||
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
}
else if (rqdata->fat_num <= 6) {
ffc12af0: 39 20 00 00 li r9,0 <== NOT EXECUTED
ffc12af4: 7c 00 00 26 mfcr r0 <== NOT EXECUTED
ffc12af8: 54 00 e0 06 rlwinm r0,r0,28,0,3 <== NOT EXECUTED
ffc12afc: 90 01 02 b8 stw r0,696(r1) <== NOT EXECUTED
* for FAT32: root directory is in cluster 2
*/
fmt_params->root_dir_start_sec =
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
ffc12b00: 80 01 00 6c lwz r0,108(r1) <== NOT EXECUTED
}
else {
/*
* for FAT32: root directory is in cluster 2
*/
fmt_params->root_dir_start_sec =
ffc12b04: 91 21 00 80 stw r9,128(r1) <== NOT EXECUTED
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
ffc12b08: 90 01 00 84 stw r0,132(r1) <== NOT EXECUTED
}
/*
* determine usable OEMName
*/
if (ret_val == 0) {
ffc12b0c: 80 01 02 b8 lwz r0,696(r1)
ffc12b10: 54 00 20 3e rotlwi r0,r0,4
ffc12b14: 7c 00 11 20 mtcrf 1,r0
ffc12b18: 54 00 e0 3e rotlwi r0,r0,28
ffc12b1c: 41 9e 00 18 beq- cr7,ffc12b34 <msdos_format+0x4b4> <== ALWAYS TAKEN
}
/*
* Phuuu.... That's it.
*/
if (ret_val != 0) {
rtems_set_errno_and_return_minus_one(ret_val);
ffc12b20: 48 01 16 f1 bl ffc24210 <__errno> <== NOT EXECUTED
ffc12b24: 3b 00 ff ff li r24,-1 <== NOT EXECUTED
ffc12b28: 93 63 00 00 stw r27,0(r3) <== NOT EXECUTED
/*
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
ffc12b2c: 41 92 fc 48 beq+ cr4,ffc12774 <msdos_format+0xf4> <== NOT EXECUTED
ffc12b30: 4b ff fd 8c b ffc128bc <msdos_format+0x23c> <== NOT EXECUTED
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
ffc12b34: 41 8a 07 70 beq- cr2,ffc132a4 <msdos_format+0xc24> <== NEVER TAKEN
(rqdata->OEMName != NULL)) {
ffc12b38: 81 7f 00 00 lwz r11,0(r31)
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
ffc12b3c: 2f 8b 00 00 cmpwi cr7,r11,0
ffc12b40: 41 9e 07 64 beq- cr7,ffc132a4 <msdos_format+0xc24> <== NEVER TAKEN
ffc12b44: 3d 20 00 00 lis r9,0
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
}
*to = '\0';
ffc12b48: 38 00 00 08 li r0,8
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
ffc12b4c: 81 09 27 ec lwz r8,10220(r9)
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
ffc12b50: 38 c0 00 20 li r6,32
}
*to = '\0';
ffc12b54: 7c 09 03 a6 mtctr r0
/*
* determine usable OEMName
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
ffc12b58: 39 21 00 93 addi r9,r1,147
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
}
*to = '\0';
ffc12b5c: 38 e0 00 00 li r7,0
ffc12b60: 48 00 00 18 b ffc12b78 <msdos_format+0x4f8>
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
*to++ = *from++;
ffc12b64: 98 09 00 00 stb r0,0(r9)
ffc12b68: 39 29 00 01 addi r9,r9,1
ffc12b6c: 39 6b 00 01 addi r11,r11,1
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
}
*to = '\0';
ffc12b70: 98 e9 00 00 stb r7,0(r9)
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
(rqdata->OEMName != NULL)) {
from = rqdata->OEMName;
}
for (cnt = 0;
ffc12b74: 42 40 00 28 bdz- ffc12b9c <msdos_format+0x51c>
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
ffc12b78: 88 0b 00 00 lbz r0,0(r11)
ffc12b7c: 7d 48 02 14 add r10,r8,r0
ffc12b80: 89 4a 00 01 lbz r10,1(r10)
ffc12b84: 71 45 00 97 andi. r5,r10,151
ffc12b88: 40 a2 ff dc bne- ffc12b64 <msdos_format+0x4e4>
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
ffc12b8c: 98 c9 00 00 stb r6,0(r9)
ffc12b90: 39 29 00 01 addi r9,r9,1
}
*to = '\0';
ffc12b94: 98 e9 00 00 stb r7,0(r9)
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
(rqdata->OEMName != NULL)) {
from = rqdata->OEMName;
}
for (cnt = 0;
ffc12b98: 42 00 ff e0 bdnz+ ffc12b78 <msdos_format+0x4f8>
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
if ((rqdata != NULL) &&
ffc12b9c: 41 8a 06 fc beq- cr2,ffc13298 <msdos_format+0xc18> <== NEVER TAKEN
(rqdata->VolLabel != NULL)) {
ffc12ba0: 81 7f 00 04 lwz r11,4(r31)
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
if ((rqdata != NULL) &&
ffc12ba4: 2f 8b 00 00 cmpwi cr7,r11,0
ffc12ba8: 41 9e 06 f0 beq- cr7,ffc13298 <msdos_format+0xc18> <== NEVER TAKEN
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
ffc12bac: 38 00 00 01 li r0,1
ffc12bb0: 98 01 00 a8 stb r0,168(r1)
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
}
*to = '\0';
ffc12bb4: 38 00 00 0b li r0,11
/*
* determine usable Volume Label
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
ffc12bb8: 39 21 00 9c addi r9,r1,156
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
}
*to = '\0';
ffc12bbc: 7c 09 03 a6 mtctr r0
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
ffc12bc0: 38 c0 00 20 li r6,32
}
*to = '\0';
ffc12bc4: 38 e0 00 00 li r7,0
ffc12bc8: 48 00 00 18 b ffc12be0 <msdos_format+0x560>
}
for (cnt = 0;
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
*to++ = *from++;
ffc12bcc: 98 09 00 00 stb r0,0(r9)
ffc12bd0: 39 29 00 01 addi r9,r9,1
ffc12bd4: 39 6b 00 01 addi r11,r11,1
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
}
*to = '\0';
ffc12bd8: 98 e9 00 00 stb r7,0(r9)
if ((rqdata != NULL) &&
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
ffc12bdc: 42 40 00 28 bdz- ffc12c04 <msdos_format+0x584>
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
ffc12be0: 88 0b 00 00 lbz r0,0(r11)
ffc12be4: 7d 48 02 14 add r10,r8,r0
ffc12be8: 89 4a 00 01 lbz r10,1(r10)
ffc12bec: 71 45 00 97 andi. r5,r10,151
ffc12bf0: 40 a2 ff dc bne- ffc12bcc <msdos_format+0x54c>
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
ffc12bf4: 98 c9 00 00 stb r6,0(r9)
ffc12bf8: 39 29 00 01 addi r9,r9,1
}
*to = '\0';
ffc12bfc: 98 e9 00 00 stb r7,0(r9)
if ((rqdata != NULL) &&
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
ffc12c00: 42 00 ff e0 bdnz+ ffc12be0 <msdos_format+0x560>
{
int ret_val = 0;
int rc;
struct timeval time_value;
rc = rtems_clock_get_tod_timeval(&time_value);
ffc12c04: 38 61 00 08 addi r3,r1,8
ffc12c08: 48 00 90 fd bl ffc1bd04 <rtems_clock_get_tod_timeval>
if (rc == RTEMS_SUCCESSFUL) {
ffc12c0c: 2f 83 00 00 cmpwi cr7,r3,0
ffc12c10: 40 9e 06 dc bne- cr7,ffc132ec <msdos_format+0xc6c> <== ALWAYS TAKEN
*volid_ptr = time_value.tv_sec + time_value.tv_sec;
ffc12c14: 80 01 00 08 lwz r0,8(r1) <== NOT EXECUTED
ffc12c18: 54 00 08 3c rlwinm r0,r0,1,0,30 <== NOT EXECUTED
ffc12c1c: 90 01 00 ac stw r0,172(r1) <== NOT EXECUTED
ret_val = msdos_format_determine_fmt_params(dd,rqdata,&fmt_params);
}
/*
* if requested, write whole disk/partition with 0xe5
*/
if ((ret_val == 0) &&
ffc12c20: 41 8a 00 10 beq- cr2,ffc12c30 <msdos_format+0x5b0> <== NEVER TAKEN
(rqdata != NULL) &&
ffc12c24: 88 1f 00 16 lbz r0,22(r31)
ffc12c28: 2f 80 00 00 cmpwi cr7,r0,0
ffc12c2c: 41 9e 03 7c beq- cr7,ffc12fa8 <msdos_format+0x928> <== ALWAYS TAKEN
*/
if (ret_val == 0) {
/*
* Read the current MBR to obtain the partition table.
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc12c30: 3c a0 ff c3 lis r5,-61
ffc12c34: 7f e3 fb 78 mr r3,r31
ffc12c38: 38 80 00 02 li r4,2
ffc12c3c: 38 a5 4f 2c addi r5,r5,20268
ffc12c40: 4c c6 31 82 crclr 4*cr1+eq
ffc12c44: 4b ff f6 e5 bl ffc12328 <msdos_format_printf>
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
ffc12c48: 7f c3 f3 78 mr r3,r30
ffc12c4c: 38 a0 00 00 li r5,0
/*
* Read the current MBR to obtain the partition table.
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"read MRB sector\n");
ret_val = msdos_format_read_sec(fd,
ffc12c50: 83 61 00 60 lwz r27,96(r1)
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
ffc12c54: 38 c0 00 00 li r6,0
ffc12c58: 38 e0 00 00 li r7,0
ffc12c5c: 4b ff 5e 55 bl ffc08ab0 <lseek>
ffc12c60: 2f 83 00 00 cmpwi cr7,r3,0
ffc12c64: 41 9c 03 38 blt- cr7,ffc12f9c <msdos_format+0x91c> <== NEVER TAKEN
ret_val = -1;
}
if (ret_val == 0) {
if (0 > read(fd,buffer,sector_size)) {
ffc12c68: 7f c3 f3 78 mr r3,r30
ffc12c6c: 38 81 00 b0 addi r4,r1,176
ffc12c70: 7f 65 db 78 mr r5,r27
ffc12c74: 4b ff 71 ad bl ffc09e20 <read>
ffc12c78: 2f 83 00 00 cmpwi cr7,r3,0
ffc12c7c: 41 9c 03 20 blt- cr7,ffc12f9c <msdos_format+0x91c> <== NEVER TAKEN
ret_val = msdos_format_read_sec(fd,
0,
fmt_params.bytes_per_sector,
tmp_sec);
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc12c80: 3c a0 ff c3 lis r5,-61
ffc12c84: 7f e3 fb 78 mr r3,r31
ffc12c88: 38 80 00 02 li r4,2
ffc12c8c: 38 a5 4f b4 addi r5,r5,20404
ffc12c90: 4c c6 31 82 crclr 4*cr1+eq
ffc12c94: 4b ff f6 95 bl ffc12328 <msdos_format_printf>
{
uint32_t total_sectors_num16 = 0;
uint32_t total_sectors_num32 = 0;
/* store total sector count in either 16 or 32 bit field in mbr */
if (fmt_params->totl_sector_cnt < 0x10000) {
ffc12c98: 83 01 00 64 lwz r24,100(r1)
ffc12c9c: 2b 98 ff ff cmplwi cr7,r24,65535
ffc12ca0: 40 9d 03 74 ble- cr7,ffc13014 <msdos_format+0x994> <== ALWAYS TAKEN
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
ret_val = -1;
}
if (ret_val == 0) {
if (0 > read(fd,buffer,sector_size)) {
ffc12ca4: 57 1c 06 3e clrlwi r28,r24,24 <== NOT EXECUTED
ffc12ca8: 57 1a c6 3e rlwinm r26,r24,24,24,31 <== NOT EXECUTED
ffc12cac: 57 19 86 3e rlwinm r25,r24,16,24,31 <== NOT EXECUTED
{
uint32_t total_sectors_num16 = 0;
uint32_t total_sectors_num32 = 0;
/* store total sector count in either 16 or 32 bit field in mbr */
if (fmt_params->totl_sector_cnt < 0x10000) {
ffc12cb0: 3a e0 00 00 li r23,0 <== NOT EXECUTED
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
ret_val = -1;
}
if (ret_val == 0) {
if (0 > read(fd,buffer,sector_size)) {
ffc12cb4: 57 18 46 3e rlwinm r24,r24,8,24,31 <== NOT EXECUTED
{
uint32_t total_sectors_num16 = 0;
uint32_t total_sectors_num32 = 0;
/* store total sector count in either 16 or 32 bit field in mbr */
if (fmt_params->totl_sector_cnt < 0x10000) {
ffc12cb8: 3a c0 00 00 li r22,0 <== NOT EXECUTED
* finally we are there: let's fill in the values into the MBR
* but first clear the MRB leaving the partition table.
*/
#define RTEMS_IDE_PARTITION_TABLE_OFFSET 0x1be
#define RTEMS_IDE_PARTITION_TABLE_SIZE (4 * 16)
memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);
ffc12cbc: 38 80 00 00 li r4,0
ffc12cc0: 38 a0 01 be li r5,446
ffc12cc4: 38 61 00 b0 addi r3,r1,176
ffc12cc8: 48 01 24 61 bl ffc25128 <memset>
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
ffc12ccc: 89 61 00 92 lbz r11,146(r1)
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
ffc12cd0: 80 01 00 78 lwz r0,120(r1)
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
fmt_params->OEMName,
FAT_BR_OEMNAME_SIZE);
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
ffc12cd4: 57 64 c2 3e rlwinm r4,r27,24,8,31
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
ffc12cd8: 2f 8b 00 04 cmpwi cr7,r11,4
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
fmt_params->OEMName,
FAT_BR_OEMNAME_SIZE);
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
ffc12cdc: 81 21 00 68 lwz r9,104(r1)
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
ffc12ce0: 54 06 c2 3e rlwinm r6,r0,24,8,31
ffc12ce4: 98 01 00 c1 stb r0,193(r1)
* but first clear the MRB leaving the partition table.
*/
#define RTEMS_IDE_PARTITION_TABLE_OFFSET 0x1be
#define RTEMS_IDE_PARTITION_TABLE_SIZE (4 * 16)
memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);
memset(mbr + RTEMS_IDE_PARTITION_TABLE_OFFSET + RTEMS_IDE_PARTITION_TABLE_SIZE,
ffc12ce8: 39 40 00 00 li r10,0
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
ffc12cec: 88 01 00 91 lbz r0,145(r1)
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
fmt_params->OEMName,
FAT_BR_OEMNAME_SIZE);
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
ffc12cf0: 55 25 c2 3e rlwinm r5,r9,24,8,31
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
ffc12cf4: 80 61 00 97 lwz r3,151(r1)
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
ffc12cf8: 38 e0 00 02 li r7,2
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
ffc12cfc: 81 81 00 93 lwz r12,147(r1)
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
ffc12d00: 39 00 00 01 li r8,1
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
fmt_params->OEMName,
FAT_BR_OEMNAME_SIZE);
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
ffc12d04: 98 81 00 bc stb r4,188(r1)
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
ffc12d08: 98 01 00 c5 stb r0,197(r1)
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
ffc12d0c: 38 00 ff ff li r0,-1
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
fmt_params->OEMName,
FAT_BR_OEMNAME_SIZE);
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
ffc12d10: 80 81 00 6c lwz r4,108(r1)
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
ffc12d14: 98 01 00 c8 stb r0,200(r1)
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
ffc12d18: 38 00 00 06 li r0,6
* but first clear the MRB leaving the partition table.
*/
#define RTEMS_IDE_PARTITION_TABLE_OFFSET 0x1be
#define RTEMS_IDE_PARTITION_TABLE_SIZE (4 * 16)
memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);
memset(mbr + RTEMS_IDE_PARTITION_TABLE_OFFSET + RTEMS_IDE_PARTITION_TABLE_SIZE,
ffc12d1c: b1 41 02 ae sth r10,686(r1)
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
ffc12d20: 91 81 00 b3 stw r12,179(r1)
ffc12d24: 90 61 00 b7 stw r3,183(r1)
fmt_params->OEMName,
FAT_BR_OEMNAME_SIZE);
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
ffc12d28: 9b 61 00 bb stb r27,187(r1)
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
ffc12d2c: 98 81 00 bd stb r4,189(r1)
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
ffc12d30: 99 21 00 be stb r9,190(r1)
ffc12d34: 98 a1 00 bf stb r5,191(r1)
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
ffc12d38: 98 e1 00 c0 stb r7,192(r1)
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
ffc12d3c: 98 c1 00 c2 stb r6,194(r1)
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
ffc12d40: 9a c1 00 c3 stb r22,195(r1)
ffc12d44: 9a e1 00 c4 stb r23,196(r1)
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
ffc12d48: 98 01 00 ca stb r0,202(r1)
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
ffc12d4c: 99 01 00 cc stb r8,204(r1)
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
ffc12d50: 9b 81 00 d0 stb r28,208(r1)
ffc12d54: 9b 41 00 d1 stb r26,209(r1)
ffc12d58: 9b 21 00 d2 stb r25,210(r1)
ffc12d5c: 9b 01 00 d3 stb r24,211(r1)
if (fmt_params->fattype != FAT_FAT32) {
ffc12d60: 41 9e 05 bc beq- cr7,ffc1331c <msdos_format+0xc9c> <== NEVER TAKEN
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
fmt_params->VolLabel,
FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),
ffc12d64: 2f 8b 00 01 cmpwi cr7,r11,1
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
ffc12d68: 80 01 00 ac lwz r0,172(r1)
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
ffc12d6c: 81 21 00 70 lwz r9,112(r1)
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
ffc12d70: 54 05 c6 3e rlwinm r5,r0,24,24,31
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
ffc12d74: 81 01 00 a0 lwz r8,160(r1)
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
ffc12d78: 54 06 84 3e rlwinm r6,r0,16,16,31
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
ffc12d7c: a1 41 00 a4 lhz r10,164(r1)
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
ffc12d80: 54 07 46 3e rlwinm r7,r0,8,24,31
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
ffc12d84: 89 61 00 a6 lbz r11,166(r1)
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
ffc12d88: 98 01 00 d7 stb r0,215(r1)
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
ffc12d8c: 55 24 c2 3e rlwinm r4,r9,24,8,31
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
ffc12d90: 80 01 00 9c lwz r0,156(r1)
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
ffc12d94: 99 21 00 c6 stb r9,198(r1)
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
ffc12d98: 39 20 00 29 li r9,41
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
ffc12d9c: 98 81 00 c7 stb r4,199(r1)
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
ffc12da0: 99 21 00 d6 stb r9,214(r1)
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
ffc12da4: 98 a1 00 d8 stb r5,216(r1)
ffc12da8: 98 c1 00 d9 stb r6,217(r1)
ffc12dac: 98 e1 00 da stb r7,218(r1)
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
ffc12db0: 90 01 00 db stw r0,219(r1)
ffc12db4: 91 01 00 df stw r8,223(r1)
ffc12db8: b1 41 00 e3 sth r10,227(r1)
ffc12dbc: 99 61 00 e5 stb r11,229(r1)
fmt_params->VolLabel,
FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),
ffc12dc0: 41 9e 06 14 beq- cr7,ffc133d4 <msdos_format+0xd54> <== ALWAYS TAKEN
ffc12dc4: 3d 20 ff c3 lis r9,-61 <== NOT EXECUTED
ffc12dc8: 39 29 4e c0 addi r9,r9,20160 <== NOT EXECUTED
ffc12dcc: 81 69 00 00 lwz r11,0(r9)
ffc12dd0: 80 09 00 04 lwz r0,4(r9)
ffc12dd4: 91 61 00 e6 stw r11,230(r1)
ffc12dd8: 90 01 00 ea stw r0,234(r1)
FAT_BR_FILSYSTYPE_SIZE);
}
/*
* add boot record signature
*/
FAT_SET_BR_SIGNATURE(mbr, FAT_BR_SIGNATURE_VAL);
ffc12ddc: 38 00 00 55 li r0,85
ffc12de0: 98 01 02 ae stb r0,686(r1)
ffc12de4: 38 00 ff aa li r0,-86
/*
* write master boot record to disk
* also write copy of MBR to disk
*/
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc12de8: 3c a0 ff c3 lis r5,-61
FAT_BR_FILSYSTYPE_SIZE);
}
/*
* add boot record signature
*/
FAT_SET_BR_SIGNATURE(mbr, FAT_BR_SIGNATURE_VAL);
ffc12dec: 98 01 02 af stb r0,687(r1)
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
ffc12df0: 38 00 ff eb li r0,-21
/*
* write master boot record to disk
* also write copy of MBR to disk
*/
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc12df4: 38 80 00 02 li r4,2
FAT_SET_BR_SIGNATURE(mbr, FAT_BR_SIGNATURE_VAL);
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
ffc12df8: 98 01 00 b0 stb r0,176(r1)
FAT_SET_VAL8(mbr,1,0x3c);
ffc12dfc: 38 00 00 3c li r0,60
/*
* write master boot record to disk
* also write copy of MBR to disk
*/
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc12e00: 38 a5 4f 4c addi r5,r5,20300
ffc12e04: 7f e3 fb 78 mr r3,r31
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
FAT_SET_VAL8(mbr,1,0x3c);
ffc12e08: 98 01 00 b1 stb r0,177(r1)
FAT_SET_VAL8(mbr,2,0x90);
ffc12e0c: 38 00 ff 90 li r0,-112
ffc12e10: 98 01 00 b2 stb r0,178(r1)
/*
* write master boot record to disk
* also write copy of MBR to disk
*/
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc12e14: 4c c6 31 82 crclr 4*cr1+eq
ffc12e18: 4b ff f5 11 bl ffc12328 <msdos_format_printf>
"write MRB sector\n");
ret_val = msdos_format_write_sec(fd,
ffc12e1c: 7f c3 f3 78 mr r3,r30
ffc12e20: 38 80 00 00 li r4,0
ffc12e24: 7f 65 db 78 mr r5,r27
ffc12e28: 38 c1 00 b0 addi r6,r1,176
ffc12e2c: 4b ff f5 b1 bl ffc123dc <msdos_format_write_sec>
0,
fmt_params.bytes_per_sector,
tmp_sec);
}
if ((ret_val == 0) &&
ffc12e30: 7c 78 1b 79 mr. r24,r3
ffc12e34: 40 a2 f9 3c bne- ffc12770 <msdos_format+0xf0> <== NEVER TAKEN
(fmt_params.mbr_copy_sec != 0)) {
ffc12e38: 83 81 00 88 lwz r28,136(r1)
ret_val = msdos_format_write_sec(fd,
0,
fmt_params.bytes_per_sector,
tmp_sec);
}
if ((ret_val == 0) &&
ffc12e3c: 2f 9c 00 00 cmpwi cr7,r28,0
ffc12e40: 40 9e 03 a4 bne- cr7,ffc131e4 <msdos_format+0xb64> <== NEVER TAKEN
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ffc12e44: 83 81 00 8c lwz r28,140(r1)
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
ffc12e48: 2f 9c 00 00 cmpwi cr7,r28,0
ffc12e4c: 40 9e 02 dc bne- cr7,ffc13128 <msdos_format+0xaa8> <== NEVER TAKEN
if (ret_val == 0) {
ret_val = msdos_format_fill_sectors
(rqdata,
fd,
fmt_params.rsvd_sector_cnt, /* start sector */
fmt_params.fat_num*fmt_params.sectors_per_fat,/* sector count */
ffc12e50: 8b 81 00 90 lbz r28,144(r1)
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
ret_val = msdos_format_fill_sectors
ffc12e54: 7f e3 fb 78 mr r3,r31
ffc12e58: 80 c1 00 70 lwz r6,112(r1)
ffc12e5c: 7f c4 f3 78 mr r4,r30
ffc12e60: 80 a1 00 68 lwz r5,104(r1)
ffc12e64: 7f 67 db 78 mr r7,r27
ffc12e68: 7c dc 31 d6 mullw r6,r28,r6
ffc12e6c: 39 00 00 00 li r8,0
ffc12e70: 4b ff f5 dd bl ffc1244c <msdos_format_fill_sectors>
}
/*
* clear/init root directory
* -> write all directory sectors as 0x00
*/
if (ret_val == 0) {
ffc12e74: 7c 78 1b 79 mr. r24,r3
ffc12e78: 40 a2 f8 f8 bne- ffc12770 <msdos_format+0xf0> <== NEVER TAKEN
ret_val = msdos_format_fill_sectors
(rqdata,
ffc12e7c: 83 41 00 80 lwz r26,128(r1)
/*
* clear/init root directory
* -> write all directory sectors as 0x00
*/
if (ret_val == 0) {
ret_val = msdos_format_fill_sectors
ffc12e80: 7f e3 fb 78 mr r3,r31
ffc12e84: 80 c1 00 84 lwz r6,132(r1)
ffc12e88: 7f c4 f3 78 mr r4,r30
ffc12e8c: 7f 45 d3 78 mr r5,r26
ffc12e90: 7f 67 db 78 mr r7,r27
ffc12e94: 39 00 00 00 li r8,0
ffc12e98: 4b ff f5 b5 bl ffc1244c <msdos_format_fill_sectors>
0x00);
}
/*
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
ffc12e9c: 7c 78 1b 79 mr. r24,r3
ffc12ea0: 40 a2 fa 1c bne- ffc128bc <msdos_format+0x23c> <== NEVER TAKEN
ffc12ea4: 88 01 00 a8 lbz r0,168(r1)
ffc12ea8: 2f 80 00 00 cmpwi cr7,r0,0
ffc12eac: 41 9e fa 10 beq+ cr7,ffc128bc <msdos_format+0x23c> <== NEVER TAKEN
memset(tmp_sec,0,sizeof(tmp_sec));
ffc12eb0: 38 80 00 00 li r4,0
ffc12eb4: 38 a0 02 00 li r5,512
ffc12eb8: 38 61 00 b0 addi r3,r1,176
ffc12ebc: 48 01 22 6d bl ffc25128 <memset>
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
ffc12ec0: 88 01 00 a6 lbz r0,166(r1)
ffc12ec4: 81 61 00 a0 lwz r11,160(r1)
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
ret_val = msdos_format_write_sec
ffc12ec8: 7f c3 f3 78 mr r3,r30
/*
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
memset(tmp_sec,0,sizeof(tmp_sec));
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
ffc12ecc: a1 21 00 a4 lhz r9,164(r1)
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
ret_val = msdos_format_write_sec
ffc12ed0: 7f 44 d3 78 mr r4,r26
/*
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
memset(tmp_sec,0,sizeof(tmp_sec));
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
ffc12ed4: 81 41 00 9c lwz r10,156(r1)
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
ret_val = msdos_format_write_sec
ffc12ed8: 7f 65 db 78 mr r5,r27
/*
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
memset(tmp_sec,0,sizeof(tmp_sec));
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
ffc12edc: 98 01 00 ba stb r0,186(r1)
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
ret_val = msdos_format_write_sec
ffc12ee0: 38 c1 00 b0 addi r6,r1,176
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
memset(tmp_sec,0,sizeof(tmp_sec));
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
ffc12ee4: 38 00 00 08 li r0,8
/*
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
memset(tmp_sec,0,sizeof(tmp_sec));
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
ffc12ee8: 91 41 00 b0 stw r10,176(r1)
ffc12eec: 91 61 00 b4 stw r11,180(r1)
ffc12ef0: b1 21 00 b8 sth r9,184(r1)
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
ffc12ef4: 98 01 00 bb stb r0,187(r1)
ret_val = msdos_format_write_sec
ffc12ef8: 4b ff f4 e5 bl ffc123dc <msdos_format_write_sec>
/*
* write FAT entry 0 as (0xffffff00|Media_type)EOC,
* write FAT entry 1 as EOC
* allocate directory in a FAT32 FS
*/
if ((ret_val == 0) && fmt_params.VolLabel_present){
ffc12efc: 7c 78 1b 79 mr. r24,r3
ffc12f00: 40 a2 f9 bc bne- ffc128bc <msdos_format+0x23c> <== NEVER TAKEN
/*
* empty sector: all clusters are free/do not link further on
*/
memset(tmp_sec,0,sizeof(tmp_sec));
ffc12f04: 38 61 00 b0 addi r3,r1,176
ffc12f08: 38 80 00 00 li r4,0
ffc12f0c: 38 a0 02 00 li r5,512
ffc12f10: 48 01 22 19 bl ffc25128 <memset>
switch(fmt_params.fattype) {
ffc12f14: 88 01 00 92 lbz r0,146(r1)
ffc12f18: 2f 80 00 02 cmpwi cr7,r0,2
ffc12f1c: 41 9e 03 b0 beq- cr7,ffc132cc <msdos_format+0xc4c> <== NEVER TAKEN
ffc12f20: 2e 00 00 04 cmpwi cr4,r0,4
ffc12f24: 41 92 03 24 beq- cr4,ffc13248 <msdos_format+0xbc8> <== NEVER TAKEN
ffc12f28: 2f 80 00 01 cmpwi cr7,r0,1
ffc12f2c: 41 9e 03 84 beq- cr7,ffc132b0 <msdos_format+0xc30> <== ALWAYS TAKEN
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
break;
default:
ret_val = -1;
errno = EINVAL;
ffc12f30: 48 01 12 e1 bl ffc24210 <__errno> <== NOT EXECUTED
ffc12f34: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc12f38: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
break;
default:
ret_val = -1;
ffc12f3c: 3b 00 ff ff li r24,-1 <== NOT EXECUTED
errno = EINVAL;
}
if (fmt_params.fattype == FAT_FAT32) {
ffc12f40: 41 92 03 38 beq- cr4,ffc13278 <msdos_format+0xbf8> <== NOT EXECUTED
* to root directory, and is end of chain
* mark this in every copy of the FAT
*/
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
}
for (i = 0;
ffc12f44: 2f 9c 00 00 cmpwi cr7,r28,0
ffc12f48: 41 be f9 74 beq- cr7,ffc128bc <msdos_format+0x23c> <== NEVER TAKEN
(i < fmt_params.fat_num) && (ret_val == 0);
ffc12f4c: 2f 98 00 00 cmpwi cr7,r24,0
ffc12f50: 40 be f9 68 bne- cr7,ffc128b8 <msdos_format+0x238> <== NEVER TAKEN
ffc12f54: 83 61 00 68 lwz r27,104(r1)
ffc12f58: 3b e0 00 00 li r31,0
ffc12f5c: 83 21 00 70 lwz r25,112(r1)
ffc12f60: 83 41 00 60 lwz r26,96(r1)
ffc12f64: 48 00 00 08 b ffc12f6c <msdos_format+0x8ec>
ffc12f68: 40 ba f9 54 bne- cr6,ffc128bc <msdos_format+0x23c> <== NEVER TAKEN
i++) {
ret_val = msdos_format_write_sec
ffc12f6c: 7f 64 db 78 mr r4,r27
ffc12f70: 7f c3 f3 78 mr r3,r30
ffc12f74: 7f 45 d3 78 mr r5,r26
ffc12f78: 38 c1 00 b0 addi r6,r1,176
*/
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
}
for (i = 0;
(i < fmt_params.fat_num) && (ret_val == 0);
i++) {
ffc12f7c: 3b ff 00 01 addi r31,r31,1
ret_val = msdos_format_write_sec
ffc12f80: 4b ff f4 5d bl ffc123dc <msdos_format_write_sec>
* to root directory, and is end of chain
* mark this in every copy of the FAT
*/
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
}
for (i = 0;
ffc12f84: 7f 9c f8 00 cmpw cr7,r28,r31
(i < fmt_params.fat_num) && (ret_val == 0);
i++) {
ret_val = msdos_format_write_sec
ffc12f88: 7c 78 1b 78 mr r24,r3
* mark this in every copy of the FAT
*/
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
}
for (i = 0;
(i < fmt_params.fat_num) && (ret_val == 0);
ffc12f8c: 2f 03 00 00 cmpwi cr6,r3,0
* to root directory, and is end of chain
* mark this in every copy of the FAT
*/
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
}
for (i = 0;
ffc12f90: 7f 7b ca 14 add r27,r27,r25
ffc12f94: 41 9d ff d4 bgt+ cr7,ffc12f68 <msdos_format+0x8e8>
ffc12f98: 4b ff f9 24 b ffc128bc <msdos_format+0x23c>
}
/*
* Phuuu.... That's it.
*/
if (ret_val != 0) {
rtems_set_errno_and_return_minus_one(ret_val);
ffc12f9c: 3b 00 ff ff li r24,-1 <== NOT EXECUTED
/*
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
ffc12fa0: 41 92 f7 d4 beq+ cr4,ffc12774 <msdos_format+0xf4> <== NOT EXECUTED
ffc12fa4: 4b ff f9 18 b ffc128bc <msdos_format+0x23c> <== NOT EXECUTED
* if requested, write whole disk/partition with 0xe5
*/
if ((ret_val == 0) &&
(rqdata != NULL) &&
!(rqdata->quick_format)) {
ret_val = msdos_format_fill_sectors
ffc12fa8: 80 c1 00 64 lwz r6,100(r1)
ffc12fac: 7f e3 fb 78 mr r3,r31
ffc12fb0: 80 e1 00 60 lwz r7,96(r1)
ffc12fb4: 7f c4 f3 78 mr r4,r30
ffc12fb8: 38 a0 00 00 li r5,0
ffc12fbc: 39 00 00 e5 li r8,229
ffc12fc0: 4b ff f4 8d bl ffc1244c <msdos_format_fill_sectors>
}
/*
* create master boot record
*/
if (ret_val == 0) {
ffc12fc4: 7c 78 1b 79 mr. r24,r3
ffc12fc8: 41 a2 fc 68 beq- ffc12c30 <msdos_format+0x5b0> <== ALWAYS TAKEN
/*
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
ffc12fcc: 41 92 f7 a8 beq+ cr4,ffc12774 <msdos_format+0xf4> <== NOT EXECUTED
ffc12fd0: 4b ff f8 ec b ffc128bc <msdos_format+0x23c> <== NOT EXECUTED
}
}
}
}
if (ret_val == 0) {
ffc12fd4: 3b 60 ff ff li r27,-1 <== NOT EXECUTED
ffc12fd8: 80 01 00 70 lwz r0,112(r1) <== NOT EXECUTED
ffc12fdc: 2f 9b 00 00 cmpwi cr7,r27,0 <== NOT EXECUTED
ffc12fe0: 89 61 00 90 lbz r11,144(r1) <== NOT EXECUTED
ffc12fe4: 81 21 00 68 lwz r9,104(r1) <== NOT EXECUTED
ffc12fe8: 7d 6b 01 d6 mullw r11,r11,r0 <== NOT EXECUTED
ffc12fec: 80 01 00 7c lwz r0,124(r1) <== NOT EXECUTED
ffc12ff0: 7c a0 00 26 mfcr r5 <== NOT EXECUTED
ffc12ff4: 54 a5 e0 06 rlwinm r5,r5,28,0,3 <== NOT EXECUTED
ffc12ff8: 90 a1 02 b8 stw r5,696(r1) <== NOT EXECUTED
ffc12ffc: 7d 2b 4a 14 add r9,r11,r9 <== NOT EXECUTED
}
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
ffc13000: 2f 80 00 00 cmpwi cr7,r0,0
ffc13004: 41 be fa fc beq- cr7,ffc12b00 <msdos_format+0x480> <== NEVER TAKEN
fmt_params->root_dir_start_sec =
ffc13008: 91 21 00 80 stw r9,128(r1)
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
fmt_params->root_dir_fmt_sec_cnt = fmt_params->root_dir_sectors;
ffc1300c: 90 01 00 84 stw r0,132(r1)
ffc13010: 4b ff fa fc b ffc12b0c <msdos_format+0x48c>
{
uint32_t total_sectors_num16 = 0;
uint32_t total_sectors_num32 = 0;
/* store total sector count in either 16 or 32 bit field in mbr */
if (fmt_params->totl_sector_cnt < 0x10000) {
ffc13014: 57 16 06 3e clrlwi r22,r24,24
ffc13018: 57 17 c6 3e rlwinm r23,r24,24,24,31
ffc1301c: 3b 20 00 00 li r25,0
ffc13020: 3b 00 00 00 li r24,0
ffc13024: 3b 40 00 00 li r26,0
ffc13028: 3b 80 00 00 li r28,0
ffc1302c: 4b ff fc 90 b ffc12cbc <msdos_format+0x63c>
/* recommended: for FAT12/FAT16, always set reserved sector count to 1 */
fmt_params->rsvd_sector_cnt = 1;
/* recommended: for FAT16, set files per root directory to 512 */
/* for FAT12/FAT16, set files per root directory */
/* must fill up an even count of sectors */
if ((rqdata != NULL) &&
ffc13030: 39 4a ff ff addi r10,r10,-1 <== NOT EXECUTED
ffc13034: 4b ff f9 c8 b ffc129fc <msdos_format+0x37c> <== NOT EXECUTED
fmt_params->fattype = FAT_FAT32;
}
else if ((rqdata != NULL) &&
(rqdata->fattype != MSDOS_FMT_FATANY)) {
ret_val = -1;
errno = EINVAL;
ffc13038: 48 01 11 d9 bl ffc24210 <__errno> <== NOT EXECUTED
ffc1303c: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc13040: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
(rqdata->fattype == MSDOS_FMT_FAT32)) {
fmt_params->fattype = FAT_FAT32;
}
else if ((rqdata != NULL) &&
(rqdata->fattype != MSDOS_FMT_FATANY)) {
ret_val = -1;
ffc13044: 3b 60 ff ff li r27,-1 <== NOT EXECUTED
ffc13048: 4b ff f8 fc b ffc12944 <msdos_format+0x2c4> <== NOT EXECUTED
if ((sectors_per_cluster * bytes_per_sector)
> MS_BYTES_PER_CLUSTER_LIMIT) {
ret_val = EINVAL;
finished = true;
}
} while (!finished);
ffc1304c: 41 9a fa 1c beq+ cr6,ffc12a68 <msdos_format+0x3e8> <== NEVER TAKEN
if (ret_val != 0) {
rtems_set_errno_and_return_minus_one(ret_val);
}
else {
*sectors_per_cluster_adj = sectors_per_cluster;
*sectors_per_fat_ptr = sectors_per_fat;
ffc13050: 93 41 00 70 stw r26,112(r1)
fatdata_sect_cnt,
fmt_params->fat_num,
fmt_params->sectors_per_cluster,
§ors_per_cluster_adj,
&(fmt_params->sectors_per_fat));
fmt_params->sectors_per_cluster = sectors_per_cluster_adj;
ffc13054: 93 81 00 6c stw r28,108(r1)
/*
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
ffc13058: 41 8a 01 68 beq- cr2,ffc131c0 <msdos_format+0xb40> <== NEVER TAKEN
(rqdata->media != 0)) {
ffc1305c: 8b 9f 00 15 lbz r28,21(r31)
/*
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
ffc13060: 2f 9c 00 00 cmpwi cr7,r28,0
ffc13064: 41 9e 01 5c beq- cr7,ffc131c0 <msdos_format+0xb40> <== ALWAYS TAKEN
(rqdata->media != 0)) {
const char valid_media_codes[] =
ffc13068: 3d 20 ff c3 lis r9,-61 <== NOT EXECUTED
ffc1306c: 39 49 4e 7c addi r10,r9,20092 <== NOT EXECUTED
ffc13070: 81 69 4e 7c lwz r11,20092(r9) <== NOT EXECUTED
ffc13074: 88 0a 00 08 lbz r0,8(r10) <== NOT EXECUTED
{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};
if (NULL==memchr(valid_media_codes,
ffc13078: 38 61 00 08 addi r3,r1,8 <== NOT EXECUTED
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
(rqdata->media != 0)) {
const char valid_media_codes[] =
ffc1307c: 81 2a 00 04 lwz r9,4(r10) <== NOT EXECUTED
{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};
if (NULL==memchr(valid_media_codes,
ffc13080: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc13084: 38 a0 00 09 li r5,9 <== NOT EXECUTED
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
(rqdata->media != 0)) {
const char valid_media_codes[] =
ffc13088: 91 61 00 08 stw r11,8(r1) <== NOT EXECUTED
ffc1308c: 91 21 00 0c stw r9,12(r1) <== NOT EXECUTED
ffc13090: 98 01 00 10 stb r0,16(r1) <== NOT EXECUTED
{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};
if (NULL==memchr(valid_media_codes,
ffc13094: 48 01 1e 15 bl ffc24ea8 <memchr> <== NOT EXECUTED
ffc13098: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1309c: 41 9e 03 a0 beq- cr7,ffc1343c <msdos_format+0xdbc> <== NOT EXECUTED
sizeof(valid_media_codes))) {
ret_val = -1;
errno = EINVAL;
}
else {
fmt_params->media_code = rqdata->media;
ffc130a0: 57 29 06 3e clrlwi r9,r25,24 <== NOT EXECUTED
ffc130a4: 80 01 00 68 lwz r0,104(r1) <== NOT EXECUTED
ffc130a8: 7d 29 d1 d6 mullw r9,r9,r26 <== NOT EXECUTED
ffc130ac: 9b 81 00 91 stb r28,145(r1) <== NOT EXECUTED
ffc130b0: 7d 29 02 14 add r9,r9,r0 <== NOT EXECUTED
ffc130b4: 80 01 00 7c lwz r0,124(r1) <== NOT EXECUTED
ffc130b8: 4b ff ff 48 b ffc13000 <msdos_format+0x980> <== NOT EXECUTED
* - compute storage size for FAT
* - subtract from total cluster count
*/
fatdata_cluster_cnt = fatdata_sec_cnt/sectors_per_cluster;
if (fattype == FAT_FAT12) {
fat_capacity = fatdata_cluster_cnt * 3 / 2;
ffc130bc: 1f 40 00 03 mulli r26,r0,3
ffc130c0: 57 5a f8 7e rlwinm r26,r26,31,1,31
else { /* FAT32 */
fat_capacity = fatdata_cluster_cnt * 4;
}
sectors_per_fat = ((fat_capacity
+ (bytes_per_sector - 1))
ffc130c4: 7f 5a 52 14 add r26,r26,r10
}
else { /* FAT32 */
fat_capacity = fatdata_cluster_cnt * 4;
}
sectors_per_fat = ((fat_capacity
ffc130c8: 7f 5a 4b 96 divwu r26,r26,r9
+ (bytes_per_sector - 1))
/ bytes_per_sector);
data_cluster_cnt = (fatdata_cluster_cnt -
(((sectors_per_fat * fat_num)
ffc130cc: 7c da 39 d6 mullw r6,r26,r7
+ (sectors_per_cluster - 1))
ffc130d0: 38 bc ff ff addi r5,r28,-1
ffc130d4: 7c c5 32 14 add r6,r5,r6
/ sectors_per_cluster));
ffc130d8: 7c c6 e3 96 divwu r6,r6,r28
sectors_per_fat = ((fat_capacity
+ (bytes_per_sector - 1))
/ bytes_per_sector);
data_cluster_cnt = (fatdata_cluster_cnt -
ffc130dc: 7c 06 00 50 subf r0,r6,r0
+ (sectors_per_cluster - 1))
/ sectors_per_cluster));
/*
* data cluster count too big? then make sectors bigger
*/
if (((fattype == FAT_FAT12) && (data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
ffc130e0: 2b 80 0f f5 cmplwi cr7,r0,4085
((fattype == FAT_FAT16) && (data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
sectors_per_cluster *= 2;
}
else {
finished = true;
ffc130e4: 39 60 00 01 li r11,1
+ (sectors_per_cluster - 1))
/ sectors_per_cluster));
/*
* data cluster count too big? then make sectors bigger
*/
if (((fattype == FAT_FAT12) && (data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
ffc130e8: 40 bd f9 9c ble- cr7,ffc12a84 <msdos_format+0x404> <== ALWAYS TAKEN
((fattype == FAT_FAT16) && (data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
sectors_per_cluster *= 2;
ffc130ec: 57 9c 08 3c rlwinm r28,r28,1,0,30 <== NOT EXECUTED
ffc130f0: 39 60 00 00 li r11,0 <== NOT EXECUTED
ffc130f4: 4b ff f9 90 b ffc12a84 <msdos_format+0x404> <== NOT EXECUTED
fatdata_cluster_cnt = fatdata_sec_cnt/sectors_per_cluster;
if (fattype == FAT_FAT12) {
fat_capacity = fatdata_cluster_cnt * 3 / 2;
}
else if (fattype == FAT_FAT16) {
fat_capacity = fatdata_cluster_cnt * 2;
ffc130f8: 54 1a 08 3c rlwinm r26,r0,1,0,30 <== NOT EXECUTED
else { /* FAT32 */
fat_capacity = fatdata_cluster_cnt * 4;
}
sectors_per_fat = ((fat_capacity
+ (bytes_per_sector - 1))
ffc130fc: 7f 4a d2 14 add r26,r10,r26 <== NOT EXECUTED
}
else { /* FAT32 */
fat_capacity = fatdata_cluster_cnt * 4;
}
sectors_per_fat = ((fat_capacity
ffc13100: 7f 5a 4b 96 divwu r26,r26,r9 <== NOT EXECUTED
+ (bytes_per_sector - 1))
/ bytes_per_sector);
data_cluster_cnt = (fatdata_cluster_cnt -
(((sectors_per_fat * fat_num)
ffc13104: 7c da 39 d6 mullw r6,r26,r7 <== NOT EXECUTED
+ (sectors_per_cluster - 1))
ffc13108: 38 bc ff ff addi r5,r28,-1 <== NOT EXECUTED
ffc1310c: 7c c5 32 14 add r6,r5,r6 <== NOT EXECUTED
/ sectors_per_cluster));
ffc13110: 7c c6 e3 96 divwu r6,r6,r28 <== NOT EXECUTED
sectors_per_fat = ((fat_capacity
+ (bytes_per_sector - 1))
/ bytes_per_sector);
data_cluster_cnt = (fatdata_cluster_cnt -
ffc13114: 7c 06 00 50 subf r0,r6,r0 <== NOT EXECUTED
/ sectors_per_cluster));
/*
* data cluster count too big? then make sectors bigger
*/
if (((fattype == FAT_FAT12) && (data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
((fattype == FAT_FAT16) && (data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
ffc13118: 2b 80 ff f5 cmplwi cr7,r0,65525 <== NOT EXECUTED
sectors_per_cluster *= 2;
}
else {
finished = true;
ffc1311c: 39 60 00 01 li r11,1 <== NOT EXECUTED
/ sectors_per_cluster));
/*
* data cluster count too big? then make sectors bigger
*/
if (((fattype == FAT_FAT12) && (data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
((fattype == FAT_FAT16) && (data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
ffc13120: 41 bd ff cc bgt- cr7,ffc130ec <msdos_format+0xa6c> <== NOT EXECUTED
ffc13124: 4b ff f9 60 b ffc12a84 <msdos_format+0x404> <== NOT EXECUTED
\*=========================================================================*/
{
/*
* clear fsinfo sector data
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
ffc13128: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc1312c: 38 a0 02 00 li r5,512 <== NOT EXECUTED
ffc13130: 38 61 00 b0 addi r3,r1,176 <== NOT EXECUTED
ffc13134: 48 01 1f f5 bl ffc25128 <memset> <== NOT EXECUTED
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
ffc13138: 39 20 00 61 li r9,97 <== NOT EXECUTED
ffc1313c: 99 21 00 b2 stb r9,178(r1) <== NOT EXECUTED
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
/*
* write "empty" values for free cluster count and next cluster number
*/
FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO,
ffc13140: 38 00 ff ff li r0,-1 <== NOT EXECUTED
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
ffc13144: 39 00 00 52 li r8,82 <== NOT EXECUTED
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
ffc13148: 99 21 02 97 stb r9,663(r1) <== NOT EXECUTED
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
ffc1314c: 39 20 00 55 li r9,85 <== NOT EXECUTED
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
ffc13150: 39 60 00 41 li r11,65 <== NOT EXECUTED
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
ffc13154: 39 40 00 72 li r10,114 <== NOT EXECUTED
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
ffc13158: 99 21 02 ae stb r9,686(r1) <== NOT EXECUTED
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
ffc1315c: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
ffc13160: 39 20 ff aa li r9,-86 <== NOT EXECUTED
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
ffc13164: 99 01 00 b0 stb r8,176(r1) <== NOT EXECUTED
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
ffc13168: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc1316c: 7f 65 db 78 mr r5,r27 <== NOT EXECUTED
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
ffc13170: 99 01 00 b1 stb r8,177(r1) <== NOT EXECUTED
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
ffc13174: 38 c1 00 b0 addi r6,r1,176 <== NOT EXECUTED
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
ffc13178: 99 61 00 b3 stb r11,179(r1) <== NOT EXECUTED
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
ffc1317c: 99 41 02 94 stb r10,660(r1) <== NOT EXECUTED
ffc13180: 99 41 02 95 stb r10,661(r1) <== NOT EXECUTED
ffc13184: 99 61 02 96 stb r11,662(r1) <== NOT EXECUTED
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
ffc13188: 99 21 02 af stb r9,687(r1) <== NOT EXECUTED
/*
* write "empty" values for free cluster count and next cluster number
*/
FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO,
ffc1318c: 98 01 02 98 stb r0,664(r1) <== NOT EXECUTED
ffc13190: 98 01 02 99 stb r0,665(r1) <== NOT EXECUTED
ffc13194: 98 01 02 9a stb r0,666(r1) <== NOT EXECUTED
ffc13198: 98 01 02 9b stb r0,667(r1) <== NOT EXECUTED
0xffffffff);
FAT_SET_FSINFO_NEXT_FREE_CLUSTER (fsinfo+FAT_FSI_INFO,
ffc1319c: 98 01 02 9c stb r0,668(r1) <== NOT EXECUTED
ffc131a0: 98 01 02 9d stb r0,669(r1) <== NOT EXECUTED
ffc131a4: 98 01 02 9e stb r0,670(r1) <== NOT EXECUTED
ffc131a8: 98 01 02 9f stb r0,671(r1) <== NOT EXECUTED
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
ffc131ac: 4b ff f2 31 bl ffc123dc <msdos_format_write_sec> <== NOT EXECUTED
}
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
ffc131b0: 7c 78 1b 79 mr. r24,r3 <== NOT EXECUTED
ffc131b4: 41 a2 fc 9c beq- ffc12e50 <msdos_format+0x7d0> <== NOT EXECUTED
/*
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
ffc131b8: 41 92 f5 bc beq+ cr4,ffc12774 <msdos_format+0xf4> <== NOT EXECUTED
ffc131bc: 4b ff f7 00 b ffc128bc <msdos_format+0x23c> <== NOT EXECUTED
else {
fmt_params->media_code = rqdata->media;
}
}
else {
fmt_params->media_code = FAT_BR_MEDIA_FIXED;
ffc131c0: 80 01 00 70 lwz r0,112(r1)
ffc131c4: 57 29 06 3e clrlwi r9,r25,24
ffc131c8: 7d 29 01 d6 mullw r9,r9,r0
ffc131cc: 38 00 ff f8 li r0,-8
ffc131d0: 98 01 00 91 stb r0,145(r1)
ffc131d4: 80 01 00 68 lwz r0,104(r1)
ffc131d8: 7d 29 02 14 add r9,r9,r0
ffc131dc: 80 01 00 7c lwz r0,124(r1)
ffc131e0: 4b ff fe 20 b ffc13000 <msdos_format+0x980>
if ((ret_val == 0) &&
(fmt_params.mbr_copy_sec != 0)) {
/*
* write copy of MBR
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc131e4: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
ffc131e8: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc131ec: 38 80 00 02 li r4,2 <== NOT EXECUTED
ffc131f0: 38 a5 4f 60 addi r5,r5,20320 <== NOT EXECUTED
ffc131f4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc131f8: 4b ff f1 31 bl ffc12328 <msdos_format_printf> <== NOT EXECUTED
"write back up MRB sector\n");
ret_val = msdos_format_write_sec(fd,
ffc131fc: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc13200: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc13204: 7f 65 db 78 mr r5,r27 <== NOT EXECUTED
ffc13208: 38 c1 00 b0 addi r6,r1,176 <== NOT EXECUTED
ffc1320c: 4b ff f1 d1 bl ffc123dc <msdos_format_write_sec> <== NOT EXECUTED
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
ffc13210: 7c 78 1b 79 mr. r24,r3 <== NOT EXECUTED
ffc13214: 41 82 fc 30 beq+ ffc12e44 <msdos_format+0x7c4> <== NOT EXECUTED
/*
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
ffc13218: 41 92 f5 5c beq+ cr4,ffc12774 <msdos_format+0xf4> <== NOT EXECUTED
ffc1321c: 4b ff f6 a0 b ffc128bc <msdos_format+0x23c> <== NOT EXECUTED
ret_val = EINVAL;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc13220: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
ffc13224: 38 00 00 02 li r0,2 <== NOT EXECUTED
ret_val = EINVAL;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc13228: 38 60 00 00 li r3,0 <== NOT EXECUTED
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
ffc1322c: 98 01 00 90 stb r0,144(r1) <== NOT EXECUTED
ret_val = EINVAL;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc13230: 38 80 00 02 li r4,2 <== NOT EXECUTED
ffc13234: 38 a5 4e fc addi r5,r5,20220 <== NOT EXECUTED
ffc13238: 38 c0 00 02 li r6,2 <== NOT EXECUTED
ffc1323c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc13240: 4b ff f0 e9 bl ffc12328 <msdos_format_printf> <== NOT EXECUTED
ffc13244: 4b ff f6 50 b ffc12894 <msdos_format+0x214> <== NOT EXECUTED
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
break;
case FAT_FAT32:
/* FAT entry 0: 0xffffff00|media_type */
FAT_SET_VAL32(tmp_sec,0,0xffffff00|fmt_params.media_code);
ffc13248: 89 21 00 91 lbz r9,145(r1) <== NOT EXECUTED
ffc1324c: 38 00 ff ff li r0,-1 <== NOT EXECUTED
ffc13250: 98 01 00 b1 stb r0,177(r1) <== NOT EXECUTED
ffc13254: 99 21 00 b0 stb r9,176(r1) <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
ffc13258: 39 20 ff f8 li r9,-8 <== NOT EXECUTED
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
break;
case FAT_FAT32:
/* FAT entry 0: 0xffffff00|media_type */
FAT_SET_VAL32(tmp_sec,0,0xffffff00|fmt_params.media_code);
ffc1325c: 98 01 00 b2 stb r0,178(r1) <== NOT EXECUTED
ffc13260: 98 01 00 b3 stb r0,179(r1) <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
ffc13264: 98 01 00 b5 stb r0,181(r1) <== NOT EXECUTED
ffc13268: 98 01 00 b6 stb r0,182(r1) <== NOT EXECUTED
ffc1326c: 38 00 00 0f li r0,15 <== NOT EXECUTED
ffc13270: 99 21 00 b4 stb r9,180(r1) <== NOT EXECUTED
ffc13274: 98 01 00 b7 stb r0,183(r1) <== NOT EXECUTED
/*
* only first valid cluster (cluster number 2) belongs
* to root directory, and is end of chain
* mark this in every copy of the FAT
*/
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
ffc13278: 38 00 ff ff li r0,-1 <== NOT EXECUTED
ffc1327c: 39 20 ff f8 li r9,-8 <== NOT EXECUTED
ffc13280: 98 01 00 b9 stb r0,185(r1) <== NOT EXECUTED
ffc13284: 98 01 00 ba stb r0,186(r1) <== NOT EXECUTED
ffc13288: 38 00 00 0f li r0,15 <== NOT EXECUTED
ffc1328c: 99 21 00 b8 stb r9,184(r1) <== NOT EXECUTED
ffc13290: 98 01 00 bb stb r0,187(r1) <== NOT EXECUTED
ffc13294: 4b ff fc b0 b ffc12f44 <msdos_format+0x8c4> <== NOT EXECUTED
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
ffc13298: 3d 60 ff c3 lis r11,-61 <== NOT EXECUTED
ffc1329c: 39 6b 4f 28 addi r11,r11,20264 <== NOT EXECUTED
ffc132a0: 4b ff f9 14 b ffc12bb4 <msdos_format+0x534> <== NOT EXECUTED
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
ffc132a4: 3d 60 ff c3 lis r11,-61 <== NOT EXECUTED
ffc132a8: 39 6b 41 98 addi r11,r11,16792 <== NOT EXECUTED
ffc132ac: 4b ff f8 98 b ffc12b44 <msdos_format+0x4c4> <== NOT EXECUTED
memset(tmp_sec,0,sizeof(tmp_sec));
switch(fmt_params.fattype) {
case FAT_FAT12:
/* LSBits of FAT entry 0: media_type */
FAT_SET_VAL8(tmp_sec,0,(fmt_params.media_code));
ffc132b0: 88 01 00 91 lbz r0,145(r1)
ffc132b4: 98 01 00 b0 stb r0,176(r1)
/* MSBits of FAT entry 0:0xf, LSBits of FAT entry 1: LSB of EOC */
FAT_SET_VAL8(tmp_sec,1,(0x0f | (FAT_FAT12_EOC << 4)));
ffc132b8: 38 00 ff 8f li r0,-113
ffc132bc: 98 01 00 b1 stb r0,177(r1)
/* MSBits of FAT entry 1: MSBits of EOC */
FAT_SET_VAL8(tmp_sec,2,(FAT_FAT12_EOC >> 4));
ffc132c0: 38 00 ff ff li r0,-1
ffc132c4: 98 01 00 b2 stb r0,178(r1)
break;
ffc132c8: 4b ff fc 7c b ffc12f44 <msdos_format+0x8c4>
case FAT_FAT16:
/* FAT entry 0: 0xff00|media_type */
FAT_SET_VAL8(tmp_sec,0,fmt_params.media_code);
ffc132cc: 89 21 00 91 lbz r9,145(r1) <== NOT EXECUTED
FAT_SET_VAL8(tmp_sec,1,0xff);
ffc132d0: 38 00 ff ff li r0,-1 <== NOT EXECUTED
ffc132d4: 98 01 00 b1 stb r0,177(r1) <== NOT EXECUTED
FAT_SET_VAL8(tmp_sec,2,(FAT_FAT12_EOC >> 4));
break;
case FAT_FAT16:
/* FAT entry 0: 0xff00|media_type */
FAT_SET_VAL8(tmp_sec,0,fmt_params.media_code);
ffc132d8: 99 21 00 b0 stb r9,176(r1) <== NOT EXECUTED
FAT_SET_VAL8(tmp_sec,1,0xff);
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
ffc132dc: 39 20 ff f8 li r9,-8 <== NOT EXECUTED
ffc132e0: 99 21 00 b2 stb r9,178(r1) <== NOT EXECUTED
ffc132e4: 98 01 00 b3 stb r0,179(r1) <== NOT EXECUTED
break;
ffc132e8: 4b ff fc 5c b ffc12f44 <msdos_format+0x8c4> <== NOT EXECUTED
rc = rtems_clock_get_tod_timeval(&time_value);
if (rc == RTEMS_SUCCESSFUL) {
*volid_ptr = time_value.tv_sec + time_value.tv_sec;
}
else {
*volid_ptr = rand();
ffc132ec: 48 01 1f 5d bl ffc25248 <rand>
ffc132f0: 90 61 00 ac stw r3,172(r1)
ffc132f4: 4b ff f9 2c b ffc12c20 <msdos_format+0x5a0>
< ((uint32_t)FAT_FAT12_MAX_CLN)*8) {
fmt_params->fattype = FAT_FAT12;
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else if (fmt_params->totl_sector_cnt
ffc132f8: 3c 00 00 1f lis r0,31 <== NOT EXECUTED
ffc132fc: 60 00 fe 9f ori r0,r0,65183 <== NOT EXECUTED
ffc13300: 7f 9c 00 40 cmplw cr7,r28,r0 <== NOT EXECUTED
ffc13304: 41 9d 00 dc bgt- cr7,ffc133e0 <msdos_format+0xd60> <== NOT EXECUTED
< ((uint32_t)FAT_FAT16_MAX_CLN)*32) {
fmt_params->fattype = FAT_FAT16;
ffc13308: 38 00 00 02 li r0,2 <== NOT EXECUTED
ffc1330c: 98 01 00 92 stb r0,146(r1) <== NOT EXECUTED
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
ffc13310: 38 00 00 02 li r0,2 <== NOT EXECUTED
ffc13314: 90 01 00 6c stw r0,108(r1) <== NOT EXECUTED
ffc13318: 4b ff f5 94 b ffc128ac <msdos_format+0x22c> <== NOT EXECUTED
FAT_SET_BR_FAT32_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
ffc1331c: 3c c0 ff c3 lis r6,-61 <== NOT EXECUTED
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
ffc13320: 81 21 00 70 lwz r9,112(r1) <== NOT EXECUTED
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
ffc13324: 81 61 00 88 lwz r11,136(r1) <== NOT EXECUTED
FAT_SET_BR_FAT32_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
ffc13328: 38 86 4f 40 addi r4,r6,20288 <== NOT EXECUTED
ffc1332c: 80 a6 4f 40 lwz r5,20288(r6) <== NOT EXECUTED
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
ffc13330: 38 00 00 00 li r0,0 <== NOT EXECUTED
FAT_SET_BR_FAT32_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
ffc13334: 80 c4 00 04 lwz r6,4(r4) <== NOT EXECUTED
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
ffc13338: 55 3a c6 3e rlwinm r26,r9,24,24,31 <== NOT EXECUTED
ffc1333c: 55 3c 84 3e rlwinm r28,r9,16,16,31 <== NOT EXECUTED
ffc13340: 99 21 00 d4 stb r9,212(r1) <== NOT EXECUTED
ffc13344: 55 23 46 3e rlwinm r3,r9,8,24,31 <== NOT EXECUTED
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
ffc13348: 55 64 c2 3e rlwinm r4,r11,24,8,31 <== NOT EXECUTED
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
ffc1334c: 9b 41 00 d5 stb r26,213(r1) <== NOT EXECUTED
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
FAT_SET_BR_FAT32_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
ffc13350: 39 20 00 29 li r9,41 <== NOT EXECUTED
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
ffc13354: 9b 81 00 d6 stb r28,214(r1) <== NOT EXECUTED
ffc13358: 98 61 00 d7 stb r3,215(r1) <== NOT EXECUTED
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
ffc1335c: 98 e1 00 dc stb r7,220(r1) <== NOT EXECUTED
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
ffc13360: 99 01 00 e0 stb r8,224(r1) <== NOT EXECUTED
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
ffc13364: 99 61 00 e2 stb r11,226(r1) <== NOT EXECUTED
ffc13368: 98 81 00 e3 stb r4,227(r1) <== NOT EXECUTED
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
ffc1336c: 90 01 00 e4 stw r0,228(r1) <== NOT EXECUTED
ffc13370: 90 01 00 e8 stw r0,232(r1) <== NOT EXECUTED
ffc13374: 90 01 00 ec stw r0,236(r1) <== NOT EXECUTED
FAT_SET_BR_FAT32_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
ffc13378: 99 21 00 f2 stb r9,242(r1) <== NOT EXECUTED
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
ffc1337c: 90 01 00 f7 stw r0,247(r1) <== NOT EXECUTED
ffc13380: 90 01 00 fb stw r0,251(r1) <== NOT EXECUTED
ffc13384: b0 01 00 ff sth r0,255(r1) <== NOT EXECUTED
ffc13388: 99 41 01 01 stb r10,257(r1) <== NOT EXECUTED
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
ffc1338c: 90 a1 01 02 stw r5,258(r1) <== NOT EXECUTED
ffc13390: 90 c1 01 06 stw r6,262(r1) <== NOT EXECUTED
ffc13394: 4b ff fa 48 b ffc12ddc <msdos_format+0x75c> <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
if (fmt_params->fattype == FAT_FAT32) {
/* recommended: for FAT32, always set reserved sector count to 32 */
fmt_params->rsvd_sector_cnt = 32;
ffc13398: 38 00 00 20 li r0,32 <== NOT EXECUTED
/* for FAT32, always set files per root directory 0 */
fmt_params->files_per_root_dir = 0;
ffc1339c: 93 61 00 78 stw r27,120(r1) <== NOT EXECUTED
/* location of copy of MBR */
fmt_params->mbr_copy_sec = 6;
/* location of fsinfo sector */
fmt_params->fsinfo_sec = 1;
ffc133a0: 38 c0 00 20 li r6,32 <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
if (fmt_params->fattype == FAT_FAT32) {
/* recommended: for FAT32, always set reserved sector count to 32 */
fmt_params->rsvd_sector_cnt = 32;
ffc133a4: 90 01 00 68 stw r0,104(r1) <== NOT EXECUTED
/* for FAT32, always set files per root directory 0 */
fmt_params->files_per_root_dir = 0;
/* location of copy of MBR */
fmt_params->mbr_copy_sec = 6;
ffc133a8: 38 00 00 06 li r0,6 <== NOT EXECUTED
/* location of fsinfo sector */
fmt_params->fsinfo_sec = 1;
ffc133ac: 38 e0 00 00 li r7,0 <== NOT EXECUTED
/* recommended: for FAT32, always set reserved sector count to 32 */
fmt_params->rsvd_sector_cnt = 32;
/* for FAT32, always set files per root directory 0 */
fmt_params->files_per_root_dir = 0;
/* location of copy of MBR */
fmt_params->mbr_copy_sec = 6;
ffc133b0: 90 01 00 88 stw r0,136(r1) <== NOT EXECUTED
/* location of fsinfo sector */
fmt_params->fsinfo_sec = 1;
ffc133b4: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc133b8: 90 01 00 8c stw r0,140(r1) <== NOT EXECUTED
ffc133bc: 81 21 00 60 lwz r9,96(r1) <== NOT EXECUTED
ffc133c0: 4b ff f6 5c b ffc12a1c <msdos_format+0x39c> <== NOT EXECUTED
}
}
/*
* try to use user requested cluster size
*/
if ((rqdata != NULL) &&
ffc133c4: 81 61 00 6c lwz r11,108(r1) <== NOT EXECUTED
ffc133c8: 3b 60 00 00 li r27,0 <== NOT EXECUTED
ffc133cc: 7d 69 5b 78 mr r9,r11 <== NOT EXECUTED
ffc133d0: 4b ff f5 8c b ffc1295c <msdos_format+0x2dc> <== NOT EXECUTED
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
fmt_params->VolLabel,
FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),
ffc133d4: 3d 20 ff c3 lis r9,-61
ffc133d8: 39 29 4e b4 addi r9,r9,20148
ffc133dc: 4b ff f9 f0 b ffc12dcc <msdos_format+0x74c>
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else {
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
ffc133e0: 3c 1b 40 00 addis r0,r27,16384 <== NOT EXECUTED
ffc133e4: 7f 7b 00 10 subfc r27,r27,r0 <== NOT EXECUTED
ffc133e8: 7f 7b d9 10 subfe r27,r27,r27 <== NOT EXECUTED
int b;
fmt_params->fattype = FAT_FAT32;
ffc133ec: 39 20 00 04 li r9,4 <== NOT EXECUTED
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else {
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
ffc133f0: 7f 7b 00 d0 neg r27,r27 <== NOT EXECUTED
int b;
fmt_params->fattype = FAT_FAT32;
ffc133f4: 99 21 00 92 stb r9,146(r1) <== NOT EXECUTED
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else {
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
ffc133f8: 57 6a 10 3a rlwinm r10,r27,2,0,29 <== NOT EXECUTED
ffc133fc: 54 00 17 be rlwinm r0,r0,2,30,31 <== NOT EXECUTED
int b;
fmt_params->fattype = FAT_FAT32;
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
ffc13400: 39 20 00 1f li r9,31 <== NOT EXECUTED
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else {
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
ffc13404: 7d 4a 03 78 or r10,r10,r0 <== NOT EXECUTED
int b;
fmt_params->fattype = FAT_FAT32;
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
ffc13408: 7d 29 03 a6 mtctr r9 <== NOT EXECUTED
ffc1340c: 39 60 00 01 li r11,1 <== NOT EXECUTED
ffc13410: 48 00 00 08 b ffc13418 <msdos_format+0xd98> <== NOT EXECUTED
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
int b;
fmt_params->fattype = FAT_FAT32;
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
ffc13414: 42 40 00 1c bdz- ffc13430 <msdos_format+0xdb0> <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
ffc13418: 7d 60 48 30 slw r0,r11,r9 <== NOT EXECUTED
ffc1341c: 7c 05 50 39 and. r5,r0,r10 <== NOT EXECUTED
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
int b;
fmt_params->fattype = FAT_FAT32;
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
ffc13420: 39 29 ff ff addi r9,r9,-1 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
ffc13424: 41 82 ff f0 beq+ ffc13414 <msdos_format+0xd94> <== NOT EXECUTED
break;
fmt_params->sectors_per_cluster = 1 << b;
ffc13428: 90 01 00 6c stw r0,108(r1) <== NOT EXECUTED
ffc1342c: 4b ff f4 80 b ffc128ac <msdos_format+0x22c> <== NOT EXECUTED
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
int b;
fmt_params->fattype = FAT_FAT32;
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
ffc13430: 38 00 00 01 li r0,1 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
break;
fmt_params->sectors_per_cluster = 1 << b;
ffc13434: 90 01 00 6c stw r0,108(r1) <== NOT EXECUTED
ffc13438: 4b ff f4 74 b ffc128ac <msdos_format+0x22c> <== NOT EXECUTED
const char valid_media_codes[] =
{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};
if (NULL==memchr(valid_media_codes,
rqdata->media,
sizeof(valid_media_codes))) {
ret_val = -1;
ffc1343c: 3b 60 ff ff li r27,-1 <== NOT EXECUTED
errno = EINVAL;
ffc13440: 48 01 0d d1 bl ffc24210 <__errno> <== NOT EXECUTED
ffc13444: 80 01 00 70 lwz r0,112(r1) <== NOT EXECUTED
ffc13448: 2f 9b 00 00 cmpwi cr7,r27,0 <== NOT EXECUTED
ffc1344c: 89 21 00 90 lbz r9,144(r1) <== NOT EXECUTED
ffc13450: 39 60 00 16 li r11,22 <== NOT EXECUTED
ffc13454: 91 63 00 00 stw r11,0(r3) <== NOT EXECUTED
ffc13458: 7d 29 01 d6 mullw r9,r9,r0 <== NOT EXECUTED
ffc1345c: 7c a0 00 26 mfcr r5 <== NOT EXECUTED
ffc13460: 54 a5 e0 06 rlwinm r5,r5,28,0,3 <== NOT EXECUTED
ffc13464: 81 61 00 68 lwz r11,104(r1) <== NOT EXECUTED
ffc13468: 80 01 00 7c lwz r0,124(r1) <== NOT EXECUTED
ffc1346c: 7d 29 5a 14 add r9,r9,r11 <== NOT EXECUTED
ffc13470: 90 a1 02 b8 stw r5,696(r1) <== NOT EXECUTED
ffc13474: 4b ff fb 8c b ffc13000 <msdos_format+0x980> <== NOT EXECUTED
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
"formating: %s\n", devname);
/* rtems feature: no block devices, all are character devices */
if ((ret_val == 0) && (!S_ISBLK(stat_buf.st_mode))) {
ffc13478: 7f 98 e3 78 mr r24,r28 <== NOT EXECUTED
ffc1347c: 4b ff f2 ec b ffc12768 <msdos_format+0xe8> <== NOT EXECUTED
* check sectors per cluster.
* must be power of 2
* must be smaller than or equal to 128
* sectors_per_cluster*bytes_per_sector must not be bigger than 32K
*/
for (onebit = 128;onebit >= 1;onebit = onebit>>1) {
ffc13480: 91 61 00 6c stw r11,108(r1) <== NOT EXECUTED
ffc13484: 4b ff f5 0c b ffc12990 <msdos_format+0x310> <== NOT EXECUTED
ffc1244c <msdos_format_fill_sectors>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
ffc1244c: 94 21 ff c0 stwu r1,-64(r1)
ffc12450: 7d 80 00 26 mfcr r12
ffc12454: 7c 08 02 a6 mflr r0
ffc12458: 93 61 00 2c stw r27,44(r1)
ffc1245c: 7c 7b 1b 78 mr r27,r3
/*
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
ffc12460: 7c e3 3b 78 mr r3,r7
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
ffc12464: 93 01 00 20 stw r24,32(r1)
ffc12468: 93 41 00 28 stw r26,40(r1)
ffc1246c: 7d 1a 43 78 mr r26,r8
ffc12470: 93 81 00 30 stw r28,48(r1)
ffc12474: 7c 9c 23 78 mr r28,r4
ffc12478: 93 a1 00 34 stw r29,52(r1)
ffc1247c: 7c fd 3b 78 mr r29,r7
ffc12480: 93 c1 00 38 stw r30,56(r1)
ffc12484: 7c de 33 78 mr r30,r6
ffc12488: 93 e1 00 3c stw r31,60(r1)
ffc1248c: 7c bf 2b 78 mr r31,r5
ffc12490: 90 01 00 44 stw r0,68(r1)
ffc12494: 92 c1 00 18 stw r22,24(r1)
ffc12498: 92 e1 00 1c stw r23,28(r1)
ffc1249c: 93 21 00 24 stw r25,36(r1)
ffc124a0: 91 81 00 14 stw r12,20(r1)
/*
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
ffc124a4: 4b ff 69 49 bl ffc08dec <malloc>
if (fill_buffer == NULL) {
ffc124a8: 2e 03 00 00 cmpwi cr4,r3,0
ffc124ac: 7c 78 1b 78 mr r24,r3
ffc124b0: 41 92 01 6c beq- cr4,ffc1261c <msdos_format_fill_sectors+0x1d0><== NEVER TAKEN
errno = ENOMEM;
ret_val = -1;
}
else {
memset(fill_buffer,fill_byte,sector_size);
ffc124b4: 7f 44 d3 78 mr r4,r26
ffc124b8: 7f a5 eb 78 mr r5,r29
ffc124bc: 48 01 2c 6d bl ffc25128 <memset>
}
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc124c0: 3c a0 ff c3 lis r5,-61
ffc124c4: 7f 63 db 78 mr r3,r27
ffc124c8: 38 80 00 02 li r4,2
ffc124cc: 38 a5 4e 88 addi r5,r5,20104
ffc124d0: 4c c6 31 82 crclr 4*cr1+eq
ffc124d4: 4b ff fe 55 bl ffc12328 <msdos_format_printf>
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
ffc124d8: 2f 9e 00 00 cmpwi cr7,r30,0
ffc124dc: 41 9e 01 20 beq- cr7,ffc125fc <msdos_format_fill_sectors+0x1b0><== NEVER TAKEN
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
if (percent != last_percent) {
if ((percent & 1) == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
ffc124e0: 3e c0 ff c3 lis r22,-61
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
ffc124e4: 93 c1 00 08 stw r30,8(r1)
ffc124e8: 1f 5e 00 64 mulli r26,r30,100
\*=========================================================================*/
{
int ret_val = 0;
char *fill_buffer = NULL;
uint32_t total_sectors = sector_cnt;
int last_percent = -1;
ffc124ec: 3b 20 ff ff li r25,-1
while ((ret_val == 0) &&
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
if (percent != last_percent) {
if ((percent & 1) == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
ffc124f0: 3a d6 3d 30 addi r22,r22,15664
ffc124f4: 48 00 00 34 b ffc12528 <msdos_format_fill_sectors+0xdc>
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
ffc124f8: 7f e4 fb 78 mr r4,r31
ffc124fc: 7f 83 e3 78 mr r3,r28
ffc12500: 7f a5 eb 78 mr r5,r29
ffc12504: 7f 06 c3 78 mr r6,r24
ffc12508: 4b ff fe d5 bl ffc123dc <msdos_format_write_sec>
start_sector++;
ffc1250c: 3b ff 00 01 addi r31,r31,1
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
ffc12510: 7c 77 1b 79 mr. r23,r3
ffc12514: 40 82 00 64 bne- ffc12578 <msdos_format_fill_sectors+0x12c><== NEVER TAKEN
ffc12518: 80 01 00 08 lwz r0,8(r1)
ffc1251c: 35 20 ff ff addic. r9,r0,-1
ffc12520: 91 21 00 08 stw r9,8(r1)
ffc12524: 41 82 00 d8 beq- ffc125fc <msdos_format_fill_sectors+0x1b0>
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
ffc12528: 7c 1a f3 96 divwu r0,r26,r30
if (percent != last_percent) {
ffc1252c: 7f 80 c8 00 cmpw cr7,r0,r25
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
start_sector++;
sector_cnt--;
ffc12530: 3b 5a ff 9c addi r26,r26,-100
* write to consecutive sectors
*/
while ((ret_val == 0) &&
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
if (percent != last_percent) {
ffc12534: 41 be ff c4 beq- cr7,ffc124f8 <msdos_format_fill_sectors+0xac>
if ((percent & 1) == 0)
ffc12538: 7c 19 03 78 mr r25,r0
ffc1253c: 73 20 00 01 andi. r0,r25,1
ffc12540: 40 82 ff b8 bne+ ffc124f8 <msdos_format_fill_sectors+0xac>
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
ffc12544: 7f 63 db 78 mr r3,r27
ffc12548: 38 80 00 02 li r4,2
ffc1254c: 7e c5 b3 78 mr r5,r22
ffc12550: 4c c6 31 82 crclr 4*cr1+eq
ffc12554: 4b ff fd d5 bl ffc12328 <msdos_format_printf>
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
ffc12558: 7f e4 fb 78 mr r4,r31
ffc1255c: 7f 83 e3 78 mr r3,r28
ffc12560: 7f a5 eb 78 mr r5,r29
ffc12564: 7f 06 c3 78 mr r6,r24
ffc12568: 4b ff fe 75 bl ffc123dc <msdos_format_write_sec>
start_sector++;
ffc1256c: 3b ff 00 01 addi r31,r31,1
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
ffc12570: 7c 77 1b 79 mr. r23,r3
ffc12574: 41 82 ff a4 beq+ ffc12518 <msdos_format_fill_sectors+0xcc><== ALWAYS TAKEN
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
start_sector++;
sector_cnt--;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "\n");
ffc12578: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
ffc1257c: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc12580: 38 80 00 02 li r4,2 <== NOT EXECUTED
ffc12584: 38 a5 48 40 addi r5,r5,18496 <== NOT EXECUTED
ffc12588: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1258c: 4b ff fd 9d bl ffc12328 <msdos_format_printf> <== NOT EXECUTED
if (ret_val)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
ffc12590: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
ffc12594: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc12598: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc1259c: 38 a5 4e 94 addi r5,r5,20116 <== NOT EXECUTED
ffc125a0: 7f e6 fb 78 mr r6,r31 <== NOT EXECUTED
ffc125a4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc125a8: 4b ff fd 81 bl ffc12328 <msdos_format_printf> <== NOT EXECUTED
"filling error on sector: %d\n", start_sector);
/*
* cleanup
*/
if (fill_buffer != NULL) {
ffc125ac: 41 92 00 0c beq- cr4,ffc125b8 <msdos_format_fill_sectors+0x16c><== NOT EXECUTED
free(fill_buffer);
ffc125b0: 7f 03 c3 78 mr r3,r24
ffc125b4: 4b ff 5f 2d bl ffc084e0 <free>
fill_buffer = NULL;
}
return ret_val;
}
ffc125b8: 80 01 00 44 lwz r0,68(r1)
ffc125bc: 7e e3 bb 78 mr r3,r23
ffc125c0: 81 81 00 14 lwz r12,20(r1)
ffc125c4: 7c 08 03 a6 mtlr r0
ffc125c8: 82 c1 00 18 lwz r22,24(r1)
ffc125cc: 82 e1 00 1c lwz r23,28(r1)
ffc125d0: 7d 80 81 20 mtcrf 8,r12
ffc125d4: 83 01 00 20 lwz r24,32(r1)
ffc125d8: 83 21 00 24 lwz r25,36(r1)
ffc125dc: 83 41 00 28 lwz r26,40(r1)
ffc125e0: 83 61 00 2c lwz r27,44(r1)
ffc125e4: 83 81 00 30 lwz r28,48(r1)
ffc125e8: 83 a1 00 34 lwz r29,52(r1)
ffc125ec: 83 c1 00 38 lwz r30,56(r1)
ffc125f0: 83 e1 00 3c lwz r31,60(r1)
ffc125f4: 38 21 00 40 addi r1,r1,64
ffc125f8: 4e 80 00 20 blr
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
start_sector++;
sector_cnt--;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "\n");
ffc125fc: 3c a0 ff c3 lis r5,-61
ffc12600: 7f 63 db 78 mr r3,r27
ffc12604: 38 80 00 02 li r4,2
ffc12608: 38 a5 48 40 addi r5,r5,18496
ffc1260c: 4c c6 31 82 crclr 4*cr1+eq
ffc12610: 4b ff fd 19 bl ffc12328 <msdos_format_printf>
ffc12614: 3a e0 00 00 li r23,0
ffc12618: 4b ff ff 98 b ffc125b0 <msdos_format_fill_sectors+0x164>
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
if (fill_buffer == NULL) {
errno = ENOMEM;
ffc1261c: 48 01 1b f5 bl ffc24210 <__errno> <== NOT EXECUTED
ffc12620: 38 00 00 0c li r0,12 <== NOT EXECUTED
ffc12624: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
else {
memset(fill_buffer,fill_byte,sector_size);
}
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc12628: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
ffc1262c: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc12630: 38 80 00 02 li r4,2 <== NOT EXECUTED
ffc12634: 38 a5 4e 88 addi r5,r5,20104 <== NOT EXECUTED
ffc12638: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1263c: 4b ff fc ed bl ffc12328 <msdos_format_printf> <== NOT EXECUTED
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
start_sector++;
sector_cnt--;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "\n");
ffc12640: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
ffc12644: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc12648: 38 80 00 02 li r4,2 <== NOT EXECUTED
ffc1264c: 38 a5 48 40 addi r5,r5,18496 <== NOT EXECUTED
ffc12650: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc12654: 4b ff fc d5 bl ffc12328 <msdos_format_printf> <== NOT EXECUTED
if (ret_val)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
ffc12658: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
ffc1265c: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc12660: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc12664: 38 a5 4e 94 addi r5,r5,20116 <== NOT EXECUTED
ffc12668: 7f e6 fb 78 mr r6,r31 <== NOT EXECUTED
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
if (fill_buffer == NULL) {
errno = ENOMEM;
ret_val = -1;
ffc1266c: 3a e0 ff ff li r23,-1 <== NOT EXECUTED
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "\n");
if (ret_val)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
ffc12670: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc12674: 4b ff fc b5 bl ffc12328 <msdos_format_printf> <== NOT EXECUTED
"filling error on sector: %d\n", start_sector);
/*
* cleanup
*/
if (fill_buffer != NULL) {
ffc12678: 40 92 ff 38 bne+ cr4,ffc125b0 <msdos_format_fill_sectors+0x164><== NOT EXECUTED
ffc1267c: 4b ff ff 3c b ffc125b8 <msdos_format_fill_sectors+0x16c><== NOT EXECUTED
ffc12328 <msdos_format_printf>:
*/
static void
msdos_format_printf (const msdos_format_request_param_t *rqdata,
int info_level,
const char *format, ...)
{
ffc12328: 94 21 ff 88 stwu r1,-120(r1)
ffc1232c: 7c 08 02 a6 mflr r0
ffc12330: 93 e1 00 74 stw r31,116(r1)
ffc12334: 90 01 00 7c stw r0,124(r1)
ffc12338: 90 c1 00 1c stw r6,28(r1)
ffc1233c: 90 e1 00 20 stw r7,32(r1)
ffc12340: 91 01 00 24 stw r8,36(r1)
ffc12344: 91 21 00 28 stw r9,40(r1)
ffc12348: 91 41 00 2c stw r10,44(r1)
ffc1234c: 40 86 00 24 bne- cr1,ffc12370 <msdos_format_printf+0x48><== ALWAYS TAKEN
ffc12350: d8 21 00 30 stfd f1,48(r1) <== NOT EXECUTED
ffc12354: d8 41 00 38 stfd f2,56(r1) <== NOT EXECUTED
ffc12358: d8 61 00 40 stfd f3,64(r1) <== NOT EXECUTED
ffc1235c: d8 81 00 48 stfd f4,72(r1) <== NOT EXECUTED
ffc12360: d8 a1 00 50 stfd f5,80(r1) <== NOT EXECUTED
ffc12364: d8 c1 00 58 stfd f6,88(r1) <== NOT EXECUTED
ffc12368: d8 e1 00 60 stfd f7,96(r1) <== NOT EXECUTED
ffc1236c: d9 01 00 68 stfd f8,104(r1) <== NOT EXECUTED
va_list args;
va_start (args, format);
if (rqdata != NULL && rqdata->info_level >= info_level)
ffc12370: 2f 83 00 00 cmpwi cr7,r3,0
msdos_format_printf (const msdos_format_request_param_t *rqdata,
int info_level,
const char *format, ...)
{
va_list args;
va_start (args, format);
ffc12374: 38 00 00 03 li r0,3
ffc12378: 98 01 00 08 stb r0,8(r1)
ffc1237c: 38 00 00 00 li r0,0
ffc12380: 98 01 00 09 stb r0,9(r1)
ffc12384: 38 01 00 80 addi r0,r1,128
ffc12388: 90 01 00 0c stw r0,12(r1)
ffc1238c: 38 01 00 10 addi r0,r1,16
ffc12390: 90 01 00 10 stw r0,16(r1)
if (rqdata != NULL && rqdata->info_level >= info_level)
ffc12394: 41 9e 00 34 beq- cr7,ffc123c8 <msdos_format_printf+0xa0><== NEVER TAKEN
ffc12398: 80 03 00 1c lwz r0,28(r3)
ffc1239c: 7f 80 20 00 cmpw cr7,r0,r4
ffc123a0: 41 bc 00 28 blt+ cr7,ffc123c8 <msdos_format_printf+0xa0><== ALWAYS TAKEN
{
vfprintf (stdout, format, args);
ffc123a4: 3f e0 00 00 lis r31,0 <== NOT EXECUTED
ffc123a8: 81 3f 27 f4 lwz r9,10228(r31) <== NOT EXECUTED
ffc123ac: 7c a4 2b 78 mr r4,r5 <== NOT EXECUTED
ffc123b0: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
ffc123b4: 80 69 00 08 lwz r3,8(r9) <== NOT EXECUTED
ffc123b8: 48 01 a7 4d bl ffc2cb04 <vfprintf> <== NOT EXECUTED
fflush (stdout);
ffc123bc: 81 3f 27 f4 lwz r9,10228(r31) <== NOT EXECUTED
ffc123c0: 80 69 00 08 lwz r3,8(r9) <== NOT EXECUTED
ffc123c4: 48 01 23 21 bl ffc246e4 <fflush> <== NOT EXECUTED
}
va_end (args);
}
ffc123c8: 80 01 00 7c lwz r0,124(r1)
ffc123cc: 83 e1 00 74 lwz r31,116(r1)
ffc123d0: 38 21 00 78 addi r1,r1,120
ffc123d4: 7c 08 03 a6 mtlr r0
ffc123d8: 4e 80 00 20 blr
ffc123dc <msdos_format_write_sec>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
ffc123dc: 94 21 ff e8 stwu r1,-24(r1)
ffc123e0: 7c 08 02 a6 mflr r0
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
ffc123e4: 38 e0 00 00 li r7,0
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
ffc123e8: 93 e1 00 14 stw r31,20(r1)
ffc123ec: 7c bf 2b 78 mr r31,r5
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
ffc123f0: 7c a4 28 16 mulhwu r5,r4,r5
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
ffc123f4: 93 c1 00 10 stw r30,16(r1)
ffc123f8: 7c de 33 78 mr r30,r6
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
ffc123fc: 7c c4 f9 d6 mullw r6,r4,r31
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
ffc12400: 93 a1 00 0c stw r29,12(r1)
ffc12404: 90 01 00 1c stw r0,28(r1)
ffc12408: 7c 7d 1b 78 mr r29,r3
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
ffc1240c: 4b ff 66 a5 bl ffc08ab0 <lseek>
ffc12410: 2f 83 00 00 cmpwi cr7,r3,0
ffc12414: 38 60 ff ff li r3,-1
ffc12418: 41 9c 00 18 blt- cr7,ffc12430 <msdos_format_write_sec+0x54><== NEVER TAKEN
ret_val = -1;
}
if (ret_val == 0) {
if (0 > write(fd,buffer,sector_size)) {
ffc1241c: 7f a3 eb 78 mr r3,r29
ffc12420: 7f c4 f3 78 mr r4,r30
ffc12424: 7f e5 fb 78 mr r5,r31
ffc12428: 4b ff aa 95 bl ffc0cebc <write>
ffc1242c: 7c 63 fe 70 srawi r3,r3,31
ret_val = -1;
}
}
return ret_val;
}
ffc12430: 80 01 00 1c lwz r0,28(r1)
ffc12434: 83 a1 00 0c lwz r29,12(r1)
ffc12438: 7c 08 03 a6 mtlr r0
ffc1243c: 83 c1 00 10 lwz r30,16(r1)
ffc12440: 83 e1 00 14 lwz r31,20(r1)
ffc12444: 38 21 00 18 addi r1,r1,24
ffc12448: 4e 80 00 20 blr
ffc1f7e8 <msdos_free_node_info>:
* RC_OK on success, or -1 code if error occured
*
*/
int
msdos_free_node_info(rtems_filesystem_location_info_t *pathloc)
{
ffc1f7e8: 94 21 ff f0 stwu r1,-16(r1)
ffc1f7ec: 7c 08 02 a6 mflr r0
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f7f0: 38 80 00 00 li r4,0
* RC_OK on success, or -1 code if error occured
*
*/
int
msdos_free_node_info(rtems_filesystem_location_info_t *pathloc)
{
ffc1f7f4: 90 01 00 14 stw r0,20(r1)
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f7f8: 38 a0 00 00 li r5,0
int
msdos_free_node_info(rtems_filesystem_location_info_t *pathloc)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
ffc1f7fc: 81 23 00 10 lwz r9,16(r3)
* RC_OK on success, or -1 code if error occured
*
*/
int
msdos_free_node_info(rtems_filesystem_location_info_t *pathloc)
{
ffc1f800: 93 c1 00 08 stw r30,8(r1)
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
ffc1f804: 83 c9 00 34 lwz r30,52(r9)
* RC_OK on success, or -1 code if error occured
*
*/
int
msdos_free_node_info(rtems_filesystem_location_info_t *pathloc)
{
ffc1f808: 93 e1 00 0c stw r31,12(r1)
ffc1f80c: 7c 7f 1b 78 mr r31,r3
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1f810: 80 7e 00 98 lwz r3,152(r30)
ffc1f814: 4b fe df 79 bl ffc0d78c <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1f818: 2f 83 00 00 cmpwi cr7,r3,0
ffc1f81c: 40 9e 00 38 bne- cr7,ffc1f854 <msdos_free_node_info+0x6c><== NEVER TAKEN
rtems_set_errno_and_return_minus_one(EIO);
rc = fat_file_close(pathloc->mt_entry, pathloc->node_access);
ffc1f820: 80 7f 00 10 lwz r3,16(r31)
ffc1f824: 80 9f 00 00 lwz r4,0(r31)
ffc1f828: 4b ff 80 59 bl ffc17880 <fat_file_close>
ffc1f82c: 7c 7f 1b 78 mr r31,r3
rtems_semaphore_release(fs_info->vol_sema);
ffc1f830: 80 7e 00 98 lwz r3,152(r30)
ffc1f834: 4b fe e0 e5 bl ffc0d918 <rtems_semaphore_release>
return rc;
}
ffc1f838: 80 01 00 14 lwz r0,20(r1)
ffc1f83c: 7f e3 fb 78 mr r3,r31
ffc1f840: 83 c1 00 08 lwz r30,8(r1)
ffc1f844: 7c 08 03 a6 mtlr r0
ffc1f848: 83 e1 00 0c lwz r31,12(r1)
ffc1f84c: 38 21 00 10 addi r1,r1,16
ffc1f850: 4e 80 00 20 blr
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
ffc1f854: 48 00 49 bd bl ffc24210 <__errno> <== NOT EXECUTED
ffc1f858: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1f85c: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1f860: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc1f864: 4b ff ff d4 b ffc1f838 <msdos_free_node_info+0x50> <== NOT EXECUTED
ffc21084 <msdos_get_dotdot_dir_info_cluster_num_and_offset>:
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
ffc21084: 94 21 ff 80 stwu r1,-128(r1) <== NOT EXECUTED
ffc21088: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc2108c: 93 e1 00 7c stw r31,124(r1) <== NOT EXECUTED
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
ffc21090: 7c 3f 0b 78 mr r31,r1 <== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
ffc21094: 90 01 00 84 stw r0,132(r1) <== NOT EXECUTED
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
ffc21098: 38 00 00 00 li r0,0 <== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
ffc2109c: 93 01 00 60 stw r24,96(r1) <== NOT EXECUTED
ffc210a0: 7c 98 23 78 mr r24,r4 <== NOT EXECUTED
ffc210a4: 93 21 00 64 stw r25,100(r1) <== NOT EXECUTED
ffc210a8: 93 61 00 6c stw r27,108(r1) <== NOT EXECUTED
ffc210ac: 93 81 00 70 stw r28,112(r1) <== NOT EXECUTED
ffc210b0: 7c dc 33 78 mr r28,r6 <== NOT EXECUTED
ffc210b4: 93 a1 00 74 stw r29,116(r1) <== NOT EXECUTED
ffc210b8: 7c bd 2b 78 mr r29,r5 <== NOT EXECUTED
uint32_t cl4find = 0;
/*
* open fat-file corresponded to ".."
*/
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
ffc210bc: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
ffc210c0: 93 c1 00 78 stw r30,120(r1) <== NOT EXECUTED
ffc210c4: 7c 7e 1b 78 mr r30,r3 <== NOT EXECUTED
ffc210c8: 92 e1 00 5c stw r23,92(r1) <== NOT EXECUTED
ffc210cc: 93 41 00 68 stw r26,104(r1) <== NOT EXECUTED
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
ffc210d0: 94 1f 00 08 stwu r0,8(r31) <== NOT EXECUTED
uint32_t cl4find = 0;
/*
* open fat-file corresponded to ".."
*/
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
ffc210d4: 7f e5 fb 78 mr r5,r31 <== NOT EXECUTED
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
ffc210d8: 83 63 00 34 lwz r27,52(r3) <== NOT EXECUTED
uint32_t cl4find = 0;
/*
* open fat-file corresponded to ".."
*/
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
ffc210dc: 4b ff 60 c1 bl ffc1719c <fat_file_open> <== NOT EXECUTED
if (rc != RC_OK)
ffc210e0: 7c 79 1b 79 mr. r25,r3 <== NOT EXECUTED
ffc210e4: 41 82 00 3c beq- ffc21120 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x9c><== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
rc = fat_file_close(mt_entry, fat_fd);
return rc;
}
ffc210e8: 80 01 00 84 lwz r0,132(r1) <== NOT EXECUTED
ffc210ec: 7f 23 cb 78 mr r3,r25 <== NOT EXECUTED
ffc210f0: 82 e1 00 5c lwz r23,92(r1) <== NOT EXECUTED
ffc210f4: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc210f8: 83 01 00 60 lwz r24,96(r1) <== NOT EXECUTED
ffc210fc: 83 21 00 64 lwz r25,100(r1) <== NOT EXECUTED
ffc21100: 83 41 00 68 lwz r26,104(r1) <== NOT EXECUTED
ffc21104: 83 61 00 6c lwz r27,108(r1) <== NOT EXECUTED
ffc21108: 83 81 00 70 lwz r28,112(r1) <== NOT EXECUTED
ffc2110c: 83 a1 00 74 lwz r29,116(r1) <== NOT EXECUTED
ffc21110: 83 c1 00 78 lwz r30,120(r1) <== NOT EXECUTED
ffc21114: 83 e1 00 7c lwz r31,124(r1) <== NOT EXECUTED
ffc21118: 38 21 00 80 addi r1,r1,128 <== NOT EXECUTED
ffc2111c: 4e 80 00 20 blr <== NOT EXECUTED
*/
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
fat_fd->cln = cln;
ffc21120: 81 21 00 08 lwz r9,8(r1) <== NOT EXECUTED
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
ffc21124: 3c 00 00 20 lis r0,32 <== NOT EXECUTED
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
fat_fd->cln = cln;
fat_fd->fat_file_type = FAT_DIRECTORY;
ffc21128: 3b 40 00 01 li r26,1 <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->map.file_cln = 0;
ffc2112c: 93 29 00 34 stw r25,52(r9) <== NOT EXECUTED
fat_fd->map.disk_cln = fat_fd->cln;
rc = fat_file_size(mt_entry, fat_fd);
ffc21130: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc21134: 7d 24 4b 78 mr r4,r9 <== NOT EXECUTED
*/
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
fat_fd->cln = cln;
ffc21138: 93 09 00 1c stw r24,28(r9) <== NOT EXECUTED
fat_fd->fat_file_type = FAT_DIRECTORY;
ffc2113c: 93 49 00 10 stw r26,16(r9) <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
ffc21140: 90 09 00 14 stw r0,20(r9) <== NOT EXECUTED
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
ffc21144: 93 09 00 38 stw r24,56(r9) <== NOT EXECUTED
rc = fat_file_size(mt_entry, fat_fd);
ffc21148: 4b ff 70 5d bl ffc181a4 <fat_file_size> <== NOT EXECUTED
if (rc != RC_OK)
ffc2114c: 7c 79 1b 79 mr. r25,r3 <== NOT EXECUTED
ffc21150: 40 82 02 04 bne- ffc21354 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2d0><== NOT EXECUTED
return rc;
}
/* find "." node in opened directory */
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
ffc21154: 3f 00 ff c3 lis r24,-61 <== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* find "." node in opened directory */
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
ffc21158: 93 21 00 2c stw r25,44(r1) <== NOT EXECUTED
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
ffc2115c: 3b 18 3d 30 addi r24,r24,15664 <== NOT EXECUTED
ffc21160: 38 80 00 01 li r4,1 <== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* find "." node in opened directory */
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
ffc21164: 93 21 00 30 stw r25,48(r1) <== NOT EXECUTED
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
ffc21168: 38 a1 00 2c addi r5,r1,44 <== NOT EXECUTED
ffc2116c: 38 c0 00 0b li r6,11 <== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* find "." node in opened directory */
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
ffc21170: 93 21 00 34 stw r25,52(r1) <== NOT EXECUTED
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
ffc21174: 7f 03 c3 78 mr r3,r24 <== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* find "." node in opened directory */
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
ffc21178: 93 21 00 38 stw r25,56(r1) <== NOT EXECUTED
ffc2117c: 93 21 00 3c stw r25,60(r1) <== NOT EXECUTED
ffc21180: 93 21 00 40 stw r25,64(r1) <== NOT EXECUTED
ffc21184: 93 21 00 44 stw r25,68(r1) <== NOT EXECUTED
ffc21188: 93 21 00 48 stw r25,72(r1) <== NOT EXECUTED
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
ffc2118c: 4b ff e7 ed bl ffc1f978 <msdos_long_to_short> <== NOT EXECUTED
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1,
ffc21190: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc21194: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
ffc21198: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc2119c: 7f 06 c3 78 mr r6,r24 <== NOT EXECUTED
ffc211a0: 38 e0 00 01 li r7,1 <== NOT EXECUTED
ffc211a4: 39 00 00 01 li r8,1 <== NOT EXECUTED
ffc211a8: 7f a9 eb 78 mr r9,r29 <== NOT EXECUTED
ffc211ac: 39 41 00 2c addi r10,r1,44 <== NOT EXECUTED
ffc211b0: 4b ff f2 15 bl ffc203c4 <msdos_find_name_in_fat_file> <== NOT EXECUTED
MSDOS_NAME_SHORT, dir_pos, dot_node);
if (rc != RC_OK)
ffc211b4: 7c 79 1b 79 mr. r25,r3 <== NOT EXECUTED
ffc211b8: 40 82 01 9c bne- ffc21354 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2d0><== NOT EXECUTED
return rc;
}
/* find ".." node in opened directory */
memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
ffc211bc: 3f 00 ff c3 lis r24,-61 <== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* find ".." node in opened directory */
memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
ffc211c0: 93 21 00 0c stw r25,12(r1) <== NOT EXECUTED
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
ffc211c4: 3b 18 3b d8 addi r24,r24,15320 <== NOT EXECUTED
ffc211c8: 38 80 00 02 li r4,2 <== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* find ".." node in opened directory */
memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
ffc211cc: 93 21 00 10 stw r25,16(r1) <== NOT EXECUTED
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
ffc211d0: 38 a1 00 0c addi r5,r1,12 <== NOT EXECUTED
ffc211d4: 38 c0 00 0b li r6,11 <== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* find ".." node in opened directory */
memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
ffc211d8: 93 21 00 14 stw r25,20(r1) <== NOT EXECUTED
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
ffc211dc: 7f 03 c3 78 mr r3,r24 <== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* find ".." node in opened directory */
memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
ffc211e0: 93 21 00 18 stw r25,24(r1) <== NOT EXECUTED
ffc211e4: 93 21 00 1c stw r25,28(r1) <== NOT EXECUTED
ffc211e8: 93 21 00 20 stw r25,32(r1) <== NOT EXECUTED
ffc211ec: 93 21 00 24 stw r25,36(r1) <== NOT EXECUTED
ffc211f0: 93 21 00 28 stw r25,40(r1) <== NOT EXECUTED
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
ffc211f4: 4b ff e7 85 bl ffc1f978 <msdos_long_to_short> <== NOT EXECUTED
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, "..", 2,
ffc211f8: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc211fc: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
ffc21200: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc21204: 7f 06 c3 78 mr r6,r24 <== NOT EXECUTED
ffc21208: 38 e0 00 02 li r7,2 <== NOT EXECUTED
ffc2120c: 39 00 00 01 li r8,1 <== NOT EXECUTED
ffc21210: 7f a9 eb 78 mr r9,r29 <== NOT EXECUTED
ffc21214: 39 41 00 0c addi r10,r1,12 <== NOT EXECUTED
ffc21218: 4b ff f1 ad bl ffc203c4 <msdos_find_name_in_fat_file> <== NOT EXECUTED
MSDOS_NAME_SHORT, dir_pos,
dotdot_node);
if (rc != RC_OK)
{
fat_file_close(mt_entry, fat_fd);
ffc2121c: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, "..", 2,
MSDOS_NAME_SHORT, dir_pos,
dotdot_node);
if (rc != RC_OK)
ffc21220: 7c 79 1b 79 mr. r25,r3 <== NOT EXECUTED
{
fat_file_close(mt_entry, fat_fd);
ffc21224: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, "..", 2,
MSDOS_NAME_SHORT, dir_pos,
dotdot_node);
if (rc != RC_OK)
ffc21228: 40 82 01 70 bne- ffc21398 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x314><== NOT EXECUTED
{
fat_file_close(mt_entry, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
ffc2122c: a3 01 00 46 lhz r24,70(r1) <== NOT EXECUTED
ffc21230: a2 e1 00 40 lhz r23,64(r1) <== NOT EXECUTED
/* close fat-file corresponded to ".." directory */
rc = fat_file_close(mt_entry, fat_fd);
ffc21234: 4b ff 66 4d bl ffc17880 <fat_file_close> <== NOT EXECUTED
if ( rc != RC_OK )
ffc21238: 7c 79 1b 79 mr. r25,r3 <== NOT EXECUTED
ffc2123c: 40 a2 fe ac bne- ffc210e8 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x64><== NOT EXECUTED
return rc;
if ( (MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
ffc21240: a0 01 00 20 lhz r0,32(r1) <== NOT EXECUTED
ffc21244: a1 61 00 26 lhz r11,38(r1) <== NOT EXECUTED
ffc21248: 54 09 c2 3e rlwinm r9,r0,24,8,31 <== NOT EXECUTED
ffc2124c: 54 00 44 2e rlwinm r0,r0,8,16,23 <== NOT EXECUTED
ffc21250: 7d 29 03 78 or r9,r9,r0 <== NOT EXECUTED
ffc21254: 55 60 c2 3e rlwinm r0,r11,24,8,31 <== NOT EXECUTED
ffc21258: 55 6b 44 2e rlwinm r11,r11,8,16,23 <== NOT EXECUTED
ffc2125c: 55 29 80 1e rlwinm r9,r9,16,0,15 <== NOT EXECUTED
ffc21260: 7c 00 5b 78 or r0,r0,r11 <== NOT EXECUTED
ffc21264: 7d 20 03 79 or. r0,r9,r0 <== NOT EXECUTED
ffc21268: 40 82 00 18 bne- ffc21280 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1fc><== NOT EXECUTED
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
ffc2126c: 39 60 ff ff li r11,-1 <== NOT EXECUTED
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
ffc21270: 90 1d 00 04 stw r0,4(r29) <== NOT EXECUTED
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
ffc21274: 91 7d 00 08 stw r11,8(r29) <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
ffc21278: 91 7d 00 0c stw r11,12(r29) <== NOT EXECUTED
/*
* we handle root dir for all FAT types in the same way with the
* ordinary directories ( through fat_file_* calls )
*/
fat_dir_pos_init(dir_pos);
dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
ffc2127c: 93 5d 00 00 stw r26,0(r29) <== NOT EXECUTED
}
/* open fat-file corresponded to second ".." */
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
ffc21280: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc21284: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc21288: 7f e5 fb 78 mr r5,r31 <== NOT EXECUTED
ffc2128c: 4b ff 5f 11 bl ffc1719c <fat_file_open> <== NOT EXECUTED
if (rc != RC_OK)
ffc21290: 7c 79 1b 79 mr. r25,r3 <== NOT EXECUTED
ffc21294: 40 a2 fe 54 bne- ffc210e8 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x64><== NOT EXECUTED
return rc;
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
ffc21298: a0 01 00 20 lhz r0,32(r1) <== NOT EXECUTED
ffc2129c: a1 61 00 26 lhz r11,38(r1) <== NOT EXECUTED
ffc212a0: 54 09 c2 3e rlwinm r9,r0,24,8,31 <== NOT EXECUTED
ffc212a4: 54 00 44 2e rlwinm r0,r0,8,16,23 <== NOT EXECUTED
ffc212a8: 7d 29 03 78 or r9,r9,r0 <== NOT EXECUTED
ffc212ac: 55 60 c2 3e rlwinm r0,r11,24,8,31 <== NOT EXECUTED
ffc212b0: 55 6b 44 2e rlwinm r11,r11,8,16,23 <== NOT EXECUTED
ffc212b4: 55 29 80 1e rlwinm r9,r9,16,0,15 <== NOT EXECUTED
ffc212b8: 7c 00 5b 78 or r0,r0,r11 <== NOT EXECUTED
ffc212bc: 7d 20 03 79 or. r0,r9,r0 <== NOT EXECUTED
fat_fd->cln = fs_info->fat.vol.rdir_cl;
ffc212c0: 81 21 00 08 lwz r9,8(r1) <== NOT EXECUTED
/* open fat-file corresponded to second ".." */
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
ffc212c4: 40 82 00 dc bne- ffc213a0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x31c><== NOT EXECUTED
fat_fd->cln = fs_info->fat.vol.rdir_cl;
ffc212c8: 80 1b 00 38 lwz r0,56(r27) <== NOT EXECUTED
ffc212cc: 90 09 00 1c stw r0,28(r9) <== NOT EXECUTED
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
fat_fd->fat_file_type = FAT_DIRECTORY;
ffc212d0: 39 60 00 01 li r11,1 <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
ffc212d4: 80 09 00 1c lwz r0,28(r9) <== NOT EXECUTED
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
fat_fd->cln = fs_info->fat.vol.rdir_cl;
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
fat_fd->fat_file_type = FAT_DIRECTORY;
ffc212d8: 91 69 00 10 stw r11,16(r9) <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
ffc212dc: 3d 60 00 20 lis r11,32 <== NOT EXECUTED
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
rc = fat_file_size(mt_entry, fat_fd);
ffc212e0: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
fat_fd->cln = fs_info->fat.vol.rdir_cl;
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
ffc212e4: 91 69 00 14 stw r11,20(r9) <== NOT EXECUTED
fat_fd->map.file_cln = 0;
ffc212e8: 39 60 00 00 li r11,0 <== NOT EXECUTED
fat_fd->map.disk_cln = fat_fd->cln;
rc = fat_file_size(mt_entry, fat_fd);
ffc212ec: 7d 24 4b 78 mr r4,r9 <== NOT EXECUTED
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->map.file_cln = 0;
ffc212f0: 91 69 00 34 stw r11,52(r9) <== NOT EXECUTED
fat_fd->map.disk_cln = fat_fd->cln;
ffc212f4: 90 09 00 38 stw r0,56(r9) <== NOT EXECUTED
rc = fat_file_size(mt_entry, fat_fd);
ffc212f8: 4b ff 6e ad bl ffc181a4 <fat_file_size> <== NOT EXECUTED
if (rc != RC_OK)
ffc212fc: 7c 79 1b 79 mr. r25,r3 <== NOT EXECUTED
ffc21300: 40 82 00 54 bne- ffc21354 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2d0><== NOT EXECUTED
{
fat_file_close(mt_entry, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
ffc21304: 56 e5 c2 3e rlwinm r5,r23,24,8,31 <== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* in this directory find slot with specified cluster num */
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
ffc21308: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
{
fat_file_close(mt_entry, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
ffc2130c: 56 f7 44 2e rlwinm r23,r23,8,16,23 <== NOT EXECUTED
ffc21310: 57 00 c2 3e rlwinm r0,r24,24,8,31 <== NOT EXECUTED
ffc21314: 7c a5 bb 78 or r5,r5,r23 <== NOT EXECUTED
ffc21318: 57 18 44 2e rlwinm r24,r24,8,16,23 <== NOT EXECUTED
ffc2131c: 7c 18 c3 78 or r24,r0,r24 <== NOT EXECUTED
ffc21320: 54 a5 80 1e rlwinm r5,r5,16,0,15 <== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* in this directory find slot with specified cluster num */
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
ffc21324: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc21328: 7c a5 c3 78 or r5,r5,r24 <== NOT EXECUTED
ffc2132c: 7f a6 eb 78 mr r6,r29 <== NOT EXECUTED
ffc21330: 7f 87 e3 78 mr r7,r28 <== NOT EXECUTED
ffc21334: 4b ff fb 19 bl ffc20e4c <msdos_find_node_by_cluster_num_in_fat_file><== NOT EXECUTED
dir_pos, dir_entry);
if (rc != RC_OK)
{
fat_file_close(mt_entry, fat_fd);
ffc21338: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
}
/* in this directory find slot with specified cluster num */
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
dir_pos, dir_entry);
if (rc != RC_OK)
ffc2133c: 7c 79 1b 79 mr. r25,r3 <== NOT EXECUTED
{
fat_file_close(mt_entry, fat_fd);
ffc21340: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
}
/* in this directory find slot with specified cluster num */
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
dir_pos, dir_entry);
if (rc != RC_OK)
ffc21344: 40 82 00 54 bne- ffc21398 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x314><== NOT EXECUTED
{
fat_file_close(mt_entry, fat_fd);
return rc;
}
rc = fat_file_close(mt_entry, fat_fd);
ffc21348: 4b ff 65 39 bl ffc17880 <fat_file_close> <== NOT EXECUTED
ffc2134c: 7c 79 1b 78 mr r25,r3 <== NOT EXECUTED
return rc;
ffc21350: 4b ff fd 98 b ffc210e8 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x64><== NOT EXECUTED
fat_fd->map.disk_cln = fat_fd->cln;
rc = fat_file_size(mt_entry, fat_fd);
if (rc != RC_OK)
{
fat_file_close(mt_entry, fat_fd);
ffc21354: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
ffc21358: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc2135c: 4b ff 65 25 bl ffc17880 <fat_file_close> <== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
rc = fat_file_close(mt_entry, fat_fd);
return rc;
}
ffc21360: 80 01 00 84 lwz r0,132(r1) <== NOT EXECUTED
ffc21364: 7f 23 cb 78 mr r3,r25 <== NOT EXECUTED
ffc21368: 82 e1 00 5c lwz r23,92(r1) <== NOT EXECUTED
ffc2136c: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc21370: 83 01 00 60 lwz r24,96(r1) <== NOT EXECUTED
ffc21374: 83 21 00 64 lwz r25,100(r1) <== NOT EXECUTED
ffc21378: 83 41 00 68 lwz r26,104(r1) <== NOT EXECUTED
ffc2137c: 83 61 00 6c lwz r27,108(r1) <== NOT EXECUTED
ffc21380: 83 81 00 70 lwz r28,112(r1) <== NOT EXECUTED
ffc21384: 83 a1 00 74 lwz r29,116(r1) <== NOT EXECUTED
ffc21388: 83 c1 00 78 lwz r30,120(r1) <== NOT EXECUTED
ffc2138c: 83 e1 00 7c lwz r31,124(r1) <== NOT EXECUTED
ffc21390: 38 21 00 80 addi r1,r1,128 <== NOT EXECUTED
ffc21394: 4e 80 00 20 blr <== NOT EXECUTED
/* in this directory find slot with specified cluster num */
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
dir_pos, dir_entry);
if (rc != RC_OK)
{
fat_file_close(mt_entry, fat_fd);
ffc21398: 4b ff 64 e9 bl ffc17880 <fat_file_close> <== NOT EXECUTED
return rc;
ffc2139c: 4b ff fd 4c b ffc210e8 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x64><== NOT EXECUTED
return rc;
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
fat_fd->cln = fs_info->fat.vol.rdir_cl;
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
ffc213a0: 90 09 00 1c stw r0,28(r9) <== NOT EXECUTED
ffc213a4: 4b ff ff 2c b ffc212d0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x24c><== NOT EXECUTED
ffc213a8 <msdos_get_name_node>:
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
ffc213a8: 94 21 ff e0 stwu r1,-32(r1)
ffc213ac: 7c 08 02 a6 mflr r0
ffc213b0: 7c cb 33 78 mr r11,r6
ffc213b4: 90 01 00 24 stw r0,36(r1)
ffc213b8: 7c e0 3b 78 mr r0,r7
int rc = RC_OK;
fat_file_fd_t *fat_fd = parent_loc->node_access;
uint32_t dotdot_cln = 0;
/* find name in fat-file which corresponds to the directory */
rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,
ffc213bc: 7d 67 5b 78 mr r7,r11
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
ffc213c0: 93 e1 00 1c stw r31,28(r1)
ffc213c4: 7c 7f 1b 78 mr r31,r3
ffc213c8: 93 61 00 0c stw r27,12(r1)
ffc213cc: 7c bb 2b 78 mr r27,r5
int rc = RC_OK;
fat_file_fd_t *fat_fd = parent_loc->node_access;
uint32_t dotdot_cln = 0;
/* find name in fat-file which corresponds to the directory */
rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,
ffc213d0: 7f 66 db 78 mr r6,r27
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
ffc213d4: 93 81 00 10 stw r28,16(r1)
ffc213d8: 7d 3c 4b 78 mr r28,r9
int rc = RC_OK;
fat_file_fd_t *fat_fd = parent_loc->node_access;
uint32_t dotdot_cln = 0;
/* find name in fat-file which corresponds to the directory */
rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,
ffc213dc: 7f 8a e3 78 mr r10,r28
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
ffc213e0: 93 a1 00 14 stw r29,20(r1)
ffc213e4: 7d 1d 43 78 mr r29,r8
int rc = RC_OK;
fat_file_fd_t *fat_fd = parent_loc->node_access;
uint32_t dotdot_cln = 0;
/* find name in fat-file which corresponds to the directory */
rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,
ffc213e8: 7f a9 eb 78 mr r9,r29
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
ffc213ec: 93 c1 00 18 stw r30,24(r1)
ffc213f0: 7c 9e 23 78 mr r30,r4
int rc = RC_OK;
fat_file_fd_t *fat_fd = parent_loc->node_access;
uint32_t dotdot_cln = 0;
/* find name in fat-file which corresponds to the directory */
rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,
ffc213f4: 7f c5 f3 78 mr r5,r30
ffc213f8: 80 63 00 10 lwz r3,16(r3)
ffc213fc: 7c 08 03 78 mr r8,r0
ffc21400: 80 9f 00 00 lwz r4,0(r31)
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
ffc21404: 93 41 00 08 stw r26,8(r1)
int rc = RC_OK;
fat_file_fd_t *fat_fd = parent_loc->node_access;
uint32_t dotdot_cln = 0;
/* find name in fat-file which corresponds to the directory */
rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,
ffc21408: 4b ff ef bd bl ffc203c4 <msdos_find_name_in_fat_file>
create_node, name, name_len, name_type,
dir_pos, name_dir_entry);
if ((rc != RC_OK) && (rc != MSDOS_NAME_NOT_FOUND_ERR))
ffc2140c: 7c 7a 1b 79 mr. r26,r3
ffc21410: 41 82 00 38 beq- ffc21448 <msdos_get_name_node+0xa0>
ffc21414: 2f 9a 7d 01 cmpwi cr7,r26,32001
ffc21418: 41 9e 00 30 beq- cr7,ffc21448 <msdos_get_name_node+0xa0><== ALWAYS TAKEN
}
}
}
}
return rc;
}
ffc2141c: 80 01 00 24 lwz r0,36(r1)
ffc21420: 7f 43 d3 78 mr r3,r26
ffc21424: 83 61 00 0c lwz r27,12(r1)
ffc21428: 7c 08 03 a6 mtlr r0
ffc2142c: 83 41 00 08 lwz r26,8(r1)
ffc21430: 83 81 00 10 lwz r28,16(r1)
ffc21434: 83 a1 00 14 lwz r29,20(r1)
ffc21438: 83 c1 00 18 lwz r30,24(r1)
ffc2143c: 83 e1 00 1c lwz r31,28(r1)
ffc21440: 38 21 00 20 addi r1,r1,32
ffc21444: 4e 80 00 20 blr
create_node, name, name_len, name_type,
dir_pos, name_dir_entry);
if ((rc != RC_OK) && (rc != MSDOS_NAME_NOT_FOUND_ERR))
return rc;
if (!create_node)
ffc21448: 2f 9e 00 00 cmpwi cr7,r30,0
ffc2144c: 40 be ff d0 bne- cr7,ffc2141c <msdos_get_name_node+0x74>
{
/* if we search for valid name and name not found -> return */
if (rc == MSDOS_NAME_NOT_FOUND_ERR)
ffc21450: 2f 9a 7d 01 cmpwi cr7,r26,32001
ffc21454: 41 be ff c8 beq- cr7,ffc2141c <msdos_get_name_node+0x74>
* if we have deal with ".." - it is a special case :(((
*
* Really, we should return cluster num and offset not of ".." slot, but
* slot which correspondes to real directory name.
*/
if (rc == RC_OK)
ffc21458: 40 a2 ff c4 bne- ffc2141c <msdos_get_name_node+0x74> <== NEVER TAKEN
{
if (strncmp(name, "..", 2) == 0)
ffc2145c: 3c 80 ff c3 lis r4,-61
ffc21460: 7f 63 db 78 mr r3,r27
ffc21464: 38 84 3b d8 addi r4,r4,15320
ffc21468: 38 a0 00 02 li r5,2
ffc2146c: 48 00 49 dd bl ffc25e48 <strncmp>
ffc21470: 2f 83 00 00 cmpwi cr7,r3,0
ffc21474: 40 be ff a8 bne- cr7,ffc2141c <msdos_get_name_node+0x74>
{
dotdot_cln = MSDOS_EXTRACT_CLUSTER_NUM((name_dir_entry));
ffc21478: a1 7c 00 14 lhz r11,20(r28)
ffc2147c: a1 3c 00 1a lhz r9,26(r28)
ffc21480: 55 60 c2 3e rlwinm r0,r11,24,8,31
ffc21484: 55 6b 44 2e rlwinm r11,r11,8,16,23
ffc21488: 55 24 c2 3e rlwinm r4,r9,24,8,31
ffc2148c: 7c 00 5b 78 or r0,r0,r11
ffc21490: 55 29 44 2e rlwinm r9,r9,8,16,23
ffc21494: 54 00 80 1e rlwinm r0,r0,16,0,15
ffc21498: 7c 84 4b 78 or r4,r4,r9
/* are we right under root dir ? */
if (dotdot_cln == 0)
ffc2149c: 7c 04 23 79 or. r4,r0,r4
ffc214a0: 40 82 00 20 bne- ffc214c0 <msdos_get_name_node+0x118> <== NEVER TAKEN
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
ffc214a4: 38 00 ff ff li r0,-1
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
ffc214a8: 93 5d 00 04 stw r26,4(r29)
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
ffc214ac: 90 1d 00 08 stw r0,8(r29)
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
ffc214b0: 90 1d 00 0c stw r0,12(r29)
/*
* we can relax about first_char field - it never should be
* used for root dir
*/
fat_dir_pos_init(dir_pos);
dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
ffc214b4: 38 00 00 01 li r0,1
ffc214b8: 90 1d 00 00 stw r0,0(r29)
ffc214bc: 4b ff ff 60 b ffc2141c <msdos_get_name_node+0x74>
}
}
}
}
return rc;
}
ffc214c0: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
fat_dir_pos_init(dir_pos);
dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
}
else
{
rc =
ffc214c4: 7f a5 eb 78 mr r5,r29 <== NOT EXECUTED
ffc214c8: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc214cc: 7f 86 e3 78 mr r6,r28 <== NOT EXECUTED
}
}
}
}
return rc;
}
ffc214d0: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc214d4: 83 41 00 08 lwz r26,8(r1) <== NOT EXECUTED
ffc214d8: 83 61 00 0c lwz r27,12(r1) <== NOT EXECUTED
ffc214dc: 83 81 00 10 lwz r28,16(r1) <== NOT EXECUTED
ffc214e0: 83 a1 00 14 lwz r29,20(r1) <== NOT EXECUTED
ffc214e4: 83 c1 00 18 lwz r30,24(r1) <== NOT EXECUTED
ffc214e8: 83 e1 00 1c lwz r31,28(r1) <== NOT EXECUTED
ffc214ec: 38 21 00 20 addi r1,r1,32 <== NOT EXECUTED
fat_dir_pos_init(dir_pos);
dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
}
else
{
rc =
ffc214f0: 4b ff fb 94 b ffc21084 <msdos_get_dotdot_dir_info_cluster_num_and_offset><== NOT EXECUTED
ffc1fbd0 <msdos_get_token>:
msdos_token_types_t
msdos_get_token(const char *path,
int pathlen,
const char **ret_token,
int *ret_token_len)
{
ffc1fbd0: 94 21 ff e0 stwu r1,-32(r1)
ffc1fbd4: 7c 08 02 a6 mflr r0
ffc1fbd8: 93 e1 00 1c stw r31,28(r1)
int i = 0;
*ret_token = NULL;
*ret_token_len = 0;
if (pathlen == 0)
ffc1fbdc: 7c 9f 23 79 mr. r31,r4
msdos_token_types_t
msdos_get_token(const char *path,
int pathlen,
const char **ret_token,
int *ret_token_len)
{
ffc1fbe0: 90 01 00 24 stw r0,36(r1)
msdos_token_types_t type = MSDOS_NAME;
int i = 0;
*ret_token = NULL;
ffc1fbe4: 38 00 00 00 li r0,0
msdos_token_types_t
msdos_get_token(const char *path,
int pathlen,
const char **ret_token,
int *ret_token_len)
{
ffc1fbe8: 93 61 00 0c stw r27,12(r1)
ffc1fbec: 7c db 33 78 mr r27,r6
ffc1fbf0: 93 81 00 10 stw r28,16(r1)
ffc1fbf4: 7c 7c 1b 78 mr r28,r3
*ret_token = NULL;
*ret_token_len = 0;
if (pathlen == 0)
return MSDOS_NO_MORE_PATH;
ffc1fbf8: 38 60 00 00 li r3,0
msdos_token_types_t
msdos_get_token(const char *path,
int pathlen,
const char **ret_token,
int *ret_token_len)
{
ffc1fbfc: 93 a1 00 14 stw r29,20(r1)
int i = 0;
*ret_token = NULL;
*ret_token_len = 0;
if (pathlen == 0)
ffc1fc00: 3b a0 00 00 li r29,0
msdos_token_types_t
msdos_get_token(const char *path,
int pathlen,
const char **ret_token,
int *ret_token_len)
{
ffc1fc04: 93 c1 00 18 stw r30,24(r1)
ffc1fc08: 7c be 2b 78 mr r30,r5
msdos_token_types_t type = MSDOS_NAME;
int i = 0;
*ret_token = NULL;
ffc1fc0c: 90 05 00 00 stw r0,0(r5)
*ret_token_len = 0;
ffc1fc10: 90 06 00 00 stw r0,0(r6)
if (pathlen == 0)
ffc1fc14: 40 a2 00 28 bne+ ffc1fc3c <msdos_get_token+0x6c>
ffc1fc18: 48 00 00 5c b ffc1fc74 <msdos_get_token+0xa4>
return MSDOS_NO_MORE_PATH;
/*
* Check for a separator.
*/
while (!msdos_is_separator(path[i]) && (i < pathlen))
ffc1fc1c: 40 98 00 34 bge- cr6,ffc1fc50 <msdos_get_token+0x80> <== NEVER TAKEN
{
if ( !msdos_is_valid_name_char(path[i]) )
ffc1fc20: 7c 7c e8 ae lbzx r3,r28,r29
ffc1fc24: 4b ff fc cd bl ffc1f8f0 <msdos_is_valid_name_char>
return MSDOS_INVALID_TOKEN;
++i;
if ( i == MSDOS_NAME_MAX_LFN_WITH_DOT )
ffc1fc28: 2f 1d 01 03 cmpwi cr6,r29,259
/*
* Check for a separator.
*/
while (!msdos_is_separator(path[i]) && (i < pathlen))
{
if ( !msdos_is_valid_name_char(path[i]) )
ffc1fc2c: 2f 83 00 00 cmpwi cr7,r3,0
return MSDOS_INVALID_TOKEN;
++i;
if ( i == MSDOS_NAME_MAX_LFN_WITH_DOT )
ffc1fc30: 3b bd 00 01 addi r29,r29,1
/*
* Check for a separator.
*/
while (!msdos_is_separator(path[i]) && (i < pathlen))
{
if ( !msdos_is_valid_name_char(path[i]) )
ffc1fc34: 41 9e 00 64 beq- cr7,ffc1fc98 <msdos_get_token+0xc8> <== NEVER TAKEN
return MSDOS_INVALID_TOKEN;
++i;
if ( i == MSDOS_NAME_MAX_LFN_WITH_DOT )
ffc1fc38: 41 9a 00 60 beq- cr6,ffc1fc98 <msdos_get_token+0xc8> <== NEVER TAKEN
return MSDOS_NO_MORE_PATH;
/*
* Check for a separator.
*/
while (!msdos_is_separator(path[i]) && (i < pathlen))
ffc1fc3c: 7c 7c e8 ae lbzx r3,r28,r29
ffc1fc40: 4b fe a7 a5 bl ffc0a3e4 <rtems_filesystem_is_separator>
ffc1fc44: 7f 1d f8 00 cmpw cr6,r29,r31
ffc1fc48: 2f 83 00 00 cmpwi cr7,r3,0
ffc1fc4c: 41 9e ff d0 beq+ cr7,ffc1fc1c <msdos_get_token+0x4c>
*ret_token = path;
/*
* If it is just a separator then it is the current dir.
*/
if ( i == 0 )
ffc1fc50: 2f 9d 00 00 cmpwi cr7,r29,0
++i;
if ( i == MSDOS_NAME_MAX_LFN_WITH_DOT )
return MSDOS_INVALID_TOKEN;
}
*ret_token = path;
ffc1fc54: 93 9e 00 00 stw r28,0(r30)
/*
* If it is just a separator then it is the current dir.
*/
if ( i == 0 )
ffc1fc58: 40 9e 00 68 bne- cr7,ffc1fcc0 <msdos_get_token+0xf0>
{
if ( (*path != '\0') && pathlen )
ffc1fc5c: 88 1c 00 00 lbz r0,0(r28)
ffc1fc60: 2f 80 00 00 cmpwi cr7,r0,0
ffc1fc64: 41 9e 00 90 beq- cr7,ffc1fcf4 <msdos_get_token+0x124>
{
i++;
ffc1fc68: 3b a0 00 01 li r29,1
}
/*
* Set the token and token_len to the token start and length.
*/
*ret_token_len = i;
ffc1fc6c: 93 bb 00 00 stw r29,0(r27)
if ( i == 0 )
{
if ( (*path != '\0') && pathlen )
{
i++;
type = MSDOS_CURRENT_DIR;
ffc1fc70: 38 60 00 01 li r3,1
return type;
}
}
return type;
}
ffc1fc74: 80 01 00 24 lwz r0,36(r1)
ffc1fc78: 83 61 00 0c lwz r27,12(r1)
ffc1fc7c: 7c 08 03 a6 mtlr r0
ffc1fc80: 83 81 00 10 lwz r28,16(r1)
ffc1fc84: 83 a1 00 14 lwz r29,20(r1)
ffc1fc88: 83 c1 00 18 lwz r30,24(r1)
ffc1fc8c: 83 e1 00 1c lwz r31,28(r1)
ffc1fc90: 38 21 00 20 addi r1,r1,32
ffc1fc94: 4e 80 00 20 blr
ffc1fc98: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
{
if ( !msdos_is_valid_name_char(path[i]) )
return MSDOS_INVALID_TOKEN;
++i;
if ( i == MSDOS_NAME_MAX_LFN_WITH_DOT )
return MSDOS_INVALID_TOKEN;
ffc1fc9c: 38 60 00 04 li r3,4 <== NOT EXECUTED
return type;
}
}
return type;
}
ffc1fca0: 83 61 00 0c lwz r27,12(r1) <== NOT EXECUTED
ffc1fca4: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc1fca8: 83 81 00 10 lwz r28,16(r1) <== NOT EXECUTED
ffc1fcac: 83 a1 00 14 lwz r29,20(r1) <== NOT EXECUTED
ffc1fcb0: 83 c1 00 18 lwz r30,24(r1) <== NOT EXECUTED
ffc1fcb4: 83 e1 00 1c lwz r31,28(r1) <== NOT EXECUTED
ffc1fcb8: 38 21 00 20 addi r1,r1,32 <== NOT EXECUTED
ffc1fcbc: 4e 80 00 20 blr <== NOT EXECUTED
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == MSDOS_NAME )
{
if ((i == 2) && ((*ret_token)[0] == '.') && ((*ret_token)[1] == '.'))
ffc1fcc0: 2f 9d 00 02 cmpwi cr7,r29,2
}
/*
* Set the token and token_len to the token start and length.
*/
*ret_token_len = i;
ffc1fcc4: 93 bb 00 00 stw r29,0(r27)
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == MSDOS_NAME )
{
if ((i == 2) && ((*ret_token)[0] == '.') && ((*ret_token)[1] == '.'))
ffc1fcc8: 41 9e 00 38 beq- cr7,ffc1fd00 <msdos_get_token+0x130>
{
type = MSDOS_UP_DIR;
return type;
}
if ((i == 1) && ((*ret_token)[0] == '.'))
ffc1fccc: 2f 9d 00 01 cmpwi cr7,r29,1
msdos_get_token(const char *path,
int pathlen,
const char **ret_token,
int *ret_token_len)
{
msdos_token_types_t type = MSDOS_NAME;
ffc1fcd0: 38 60 00 03 li r3,3
{
type = MSDOS_UP_DIR;
return type;
}
if ((i == 1) && ((*ret_token)[0] == '.'))
ffc1fcd4: 40 9e ff a0 bne+ cr7,ffc1fc74 <msdos_get_token+0xa4>
ffc1fcd8: 88 7c 00 00 lbz r3,0(r28)
msdos_get_token(const char *path,
int pathlen,
const char **ret_token,
int *ret_token_len)
{
msdos_token_types_t type = MSDOS_NAME;
ffc1fcdc: 68 63 00 2e xori r3,r3,46
ffc1fce0: 30 63 ff ff addic r3,r3,-1
ffc1fce4: 7c 63 19 10 subfe r3,r3,r3
ffc1fce8: 54 63 00 3c rlwinm r3,r3,0,0,30
ffc1fcec: 38 63 00 03 addi r3,r3,3
ffc1fcf0: 4b ff ff 84 b ffc1fc74 <msdos_get_token+0xa4>
{
i++;
type = MSDOS_CURRENT_DIR;
}
else
type = MSDOS_NO_MORE_PATH;
ffc1fcf4: 38 60 00 00 li r3,0
}
/*
* Set the token and token_len to the token start and length.
*/
*ret_token_len = i;
ffc1fcf8: 93 bb 00 00 stw r29,0(r27)
ffc1fcfc: 4b ff ff 78 b ffc1fc74 <msdos_get_token+0xa4>
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == MSDOS_NAME )
{
if ((i == 2) && ((*ret_token)[0] == '.') && ((*ret_token)[1] == '.'))
ffc1fd00: 88 1c 00 00 lbz r0,0(r28)
msdos_get_token(const char *path,
int pathlen,
const char **ret_token,
int *ret_token_len)
{
msdos_token_types_t type = MSDOS_NAME;
ffc1fd04: 38 60 00 03 li r3,3
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == MSDOS_NAME )
{
if ((i == 2) && ((*ret_token)[0] == '.') && ((*ret_token)[1] == '.'))
ffc1fd08: 2f 80 00 2e cmpwi cr7,r0,46
ffc1fd0c: 40 9e ff 68 bne+ cr7,ffc1fc74 <msdos_get_token+0xa4> <== NEVER TAKEN
ffc1fd10: 88 7c 00 01 lbz r3,1(r28)
msdos_get_token(const char *path,
int pathlen,
const char **ret_token,
int *ret_token_len)
{
msdos_token_types_t type = MSDOS_NAME;
ffc1fd14: 68 63 00 2e xori r3,r3,46
ffc1fd18: 7c 63 00 34 cntlzw r3,r3
ffc1fd1c: 54 63 d9 7e rlwinm r3,r3,27,5,31
ffc1fd20: 20 63 00 03 subfic r3,r3,3
ffc1fd24: 4b ff ff 50 b ffc1fc74 <msdos_get_token+0xa4>
ffc134c0 <msdos_initialize_support>:
rtems_filesystem_mount_table_entry_t *temp_mt_entry,
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *file_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers
)
{
ffc134c0: 94 21 ff b8 stwu r1,-72(r1)
ffc134c4: 7c 08 02 a6 mflr r0
ffc134c8: 93 61 00 34 stw r27,52(r1)
ffc134cc: 7c 9b 23 78 mr r27,r4
msdos_fs_info_t *fs_info = NULL;
fat_file_fd_t *fat_fd = NULL;
fat_dir_pos_t root_pos;
uint32_t cl_buf_size;
fs_info = (msdos_fs_info_t *)calloc(1, sizeof(msdos_fs_info_t));
ffc134d0: 38 80 00 a0 li r4,160
rtems_filesystem_mount_table_entry_t *temp_mt_entry,
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *file_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers
)
{
ffc134d4: 90 01 00 4c stw r0,76(r1)
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = NULL;
fat_file_fd_t *fat_fd = NULL;
ffc134d8: 38 00 00 00 li r0,0
rtems_filesystem_mount_table_entry_t *temp_mt_entry,
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *file_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers
)
{
ffc134dc: 93 c1 00 40 stw r30,64(r1)
ffc134e0: 7c 7e 1b 78 mr r30,r3
msdos_fs_info_t *fs_info = NULL;
fat_file_fd_t *fat_fd = NULL;
fat_dir_pos_t root_pos;
uint32_t cl_buf_size;
fs_info = (msdos_fs_info_t *)calloc(1, sizeof(msdos_fs_info_t));
ffc134e4: 38 60 00 01 li r3,1
rtems_filesystem_mount_table_entry_t *temp_mt_entry,
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *file_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers
)
{
ffc134e8: 93 21 00 2c stw r25,44(r1)
ffc134ec: 7c b9 2b 78 mr r25,r5
ffc134f0: 93 81 00 38 stw r28,56(r1)
ffc134f4: 7c dc 33 78 mr r28,r6
ffc134f8: 93 e1 00 44 stw r31,68(r1)
ffc134fc: 93 41 00 30 stw r26,48(r1)
ffc13500: 93 a1 00 3c stw r29,60(r1)
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = NULL;
fat_file_fd_t *fat_fd = NULL;
ffc13504: 90 01 00 08 stw r0,8(r1)
fat_dir_pos_t root_pos;
uint32_t cl_buf_size;
fs_info = (msdos_fs_info_t *)calloc(1, sizeof(msdos_fs_info_t));
ffc13508: 4b ff 49 29 bl ffc07e30 <calloc>
if (!fs_info)
ffc1350c: 7c 7f 1b 79 mr. r31,r3
ffc13510: 41 82 01 a0 beq- ffc136b0 <msdos_initialize_support+0x1f0><== NEVER TAKEN
rtems_set_errno_and_return_minus_one(ENOMEM);
temp_mt_entry->fs_info = fs_info;
ffc13514: 93 fe 00 34 stw r31,52(r30)
rc = fat_init_volume_info(temp_mt_entry);
ffc13518: 7f c3 f3 78 mr r3,r30
ffc1351c: 48 00 58 c1 bl ffc18ddc <fat_init_volume_info>
if (rc != RC_OK)
ffc13520: 7c 7d 1b 79 mr. r29,r3
ffc13524: 40 82 00 f4 bne- ffc13618 <msdos_initialize_support+0x158><== NEVER TAKEN
/*
* open fat-file which correspondes to root directory
* (so inode number 0x00000010 is always used for root directory)
*/
fat_dir_pos_init(&root_pos);
root_pos.sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
ffc13528: 7c 24 0b 78 mr r4,r1
{
free(fs_info);
return rc;
}
fs_info->file_handlers = file_handlers;
ffc1352c: 93 3f 00 94 stw r25,148(r31)
/*
* open fat-file which correspondes to root directory
* (so inode number 0x00000010 is always used for root directory)
*/
fat_dir_pos_init(&root_pos);
root_pos.sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
ffc13530: 3b 40 00 01 li r26,1
ffc13534: 97 44 00 0c stwu r26,12(r4)
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
ffc13538: 38 00 ff ff li r0,-1
rc = fat_file_open(temp_mt_entry, &root_pos, &fat_fd);
ffc1353c: 7f c3 f3 78 mr r3,r30
free(fs_info);
return rc;
}
fs_info->file_handlers = file_handlers;
fs_info->directory_handlers = directory_handlers;
ffc13540: 93 9f 00 90 stw r28,144(r31)
* open fat-file which correspondes to root directory
* (so inode number 0x00000010 is always used for root directory)
*/
fat_dir_pos_init(&root_pos);
root_pos.sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
rc = fat_file_open(temp_mt_entry, &root_pos, &fat_fd);
ffc13544: 38 a1 00 08 addi r5,r1,8
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
ffc13548: 93 a1 00 10 stw r29,16(r1)
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
ffc1354c: 90 01 00 14 stw r0,20(r1)
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
ffc13550: 90 01 00 18 stw r0,24(r1)
ffc13554: 48 00 3c 49 bl ffc1719c <fat_file_open>
if (rc != RC_OK)
ffc13558: 7c 7d 1b 79 mr. r29,r3
ffc1355c: 40 82 00 b4 bne- ffc13610 <msdos_initialize_support+0x150><== NEVER TAKEN
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->cln = fs_info->fat.vol.rdir_cl;
ffc13560: 80 1f 00 38 lwz r0,56(r31)
return rc;
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
ffc13564: 3d 20 00 20 lis r9,32
free(fs_info);
return rc;
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
ffc13568: 80 81 00 08 lwz r4,8(r1)
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
/* if we have FAT12/16 */
if ( fat_fd->cln == 0 )
ffc1356c: 2f 80 00 00 cmpwi cr7,r0,0
free(fs_info);
return rc;
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
ffc13570: 93 44 00 10 stw r26,16(r4)
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
ffc13574: 91 24 00 14 stw r9,20(r4)
fat_fd->cln = fs_info->fat.vol.rdir_cl;
ffc13578: 90 04 00 1c stw r0,28(r4)
fat_fd->map.file_cln = 0;
ffc1357c: 93 a4 00 34 stw r29,52(r4)
fat_fd->map.disk_cln = fat_fd->cln;
ffc13580: 90 04 00 38 stw r0,56(r4)
/* if we have FAT12/16 */
if ( fat_fd->cln == 0 )
ffc13584: 40 9e 00 d4 bne- cr7,ffc13658 <msdos_initialize_support+0x198><== NEVER TAKEN
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
ffc13588: 80 1f 00 28 lwz r0,40(r31)
cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
fs_info->fat.vol.bpc :
ffc1358c: a0 7f 00 06 lhz r3,6(r31)
fat_fd->map.disk_cln = fat_fd->cln;
/* if we have FAT12/16 */
if ( fat_fd->cln == 0 )
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
ffc13590: 90 04 00 18 stw r0,24(r4)
cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
ffc13594: 7f 83 00 40 cmplw cr7,r3,r0
ffc13598: 41 9c 00 b8 blt- cr7,ffc13650 <msdos_initialize_support+0x190><== ALWAYS TAKEN
return rc;
}
cl_buf_size = fs_info->fat.vol.bpc;
}
fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));
ffc1359c: 38 80 00 01 li r4,1
ffc135a0: 4b ff 48 91 bl ffc07e30 <calloc>
if (fs_info->cl_buf == NULL)
ffc135a4: 2f 83 00 00 cmpwi cr7,r3,0
return rc;
}
cl_buf_size = fs_info->fat.vol.bpc;
}
fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));
ffc135a8: 90 7f 00 9c stw r3,156(r31)
if (fs_info->cl_buf == NULL)
ffc135ac: 41 9e 00 e8 beq- cr7,ffc13694 <msdos_initialize_support+0x1d4><== NEVER TAKEN
fat_shutdown_drive(temp_mt_entry);
free(fs_info);
rtems_set_errno_and_return_minus_one(ENOMEM);
}
sc = rtems_semaphore_create(3,
ffc135b0: 38 60 00 03 li r3,3
ffc135b4: 38 80 00 01 li r4,1
ffc135b8: 38 a0 00 10 li r5,16
ffc135bc: 38 c0 00 00 li r6,0
ffc135c0: 38 ff 00 98 addi r7,r31,152
ffc135c4: 4b ff 9e f1 bl ffc0d4b4 <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO,
0,
&fs_info->vol_sema);
if (sc != RTEMS_SUCCESSFUL)
ffc135c8: 2f 83 00 00 cmpwi cr7,r3,0
ffc135cc: 40 9e 00 f8 bne- cr7,ffc136c4 <msdos_initialize_support+0x204><== NEVER TAKEN
free(fs_info->cl_buf);
free(fs_info);
rtems_set_errno_and_return_minus_one( EIO );
}
temp_mt_entry->mt_fs_root.node_access = fat_fd;
ffc135d0: 80 01 00 08 lwz r0,8(r1)
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
temp_mt_entry->mt_fs_root.ops = op_table;
return rc;
}
ffc135d4: 7f a3 eb 78 mr r3,r29
free(fs_info);
rtems_set_errno_and_return_minus_one( EIO );
}
temp_mt_entry->mt_fs_root.node_access = fat_fd;
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
ffc135d8: 93 9e 00 24 stw r28,36(r30)
free(fs_info->cl_buf);
free(fs_info);
rtems_set_errno_and_return_minus_one( EIO );
}
temp_mt_entry->mt_fs_root.node_access = fat_fd;
ffc135dc: 90 1e 00 1c stw r0,28(r30)
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
temp_mt_entry->mt_fs_root.ops = op_table;
return rc;
}
ffc135e0: 80 01 00 4c lwz r0,76(r1)
rtems_set_errno_and_return_minus_one( EIO );
}
temp_mt_entry->mt_fs_root.node_access = fat_fd;
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
temp_mt_entry->mt_fs_root.ops = op_table;
ffc135e4: 93 7e 00 28 stw r27,40(r30)
return rc;
}
ffc135e8: 7c 08 03 a6 mtlr r0
ffc135ec: 83 21 00 2c lwz r25,44(r1)
ffc135f0: 83 41 00 30 lwz r26,48(r1)
ffc135f4: 83 61 00 34 lwz r27,52(r1)
ffc135f8: 83 81 00 38 lwz r28,56(r1)
ffc135fc: 83 a1 00 3c lwz r29,60(r1)
ffc13600: 83 c1 00 40 lwz r30,64(r1)
ffc13604: 83 e1 00 44 lwz r31,68(r1)
ffc13608: 38 21 00 48 addi r1,r1,72
ffc1360c: 4e 80 00 20 blr
fat_dir_pos_init(&root_pos);
root_pos.sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
rc = fat_file_open(temp_mt_entry, &root_pos, &fat_fd);
if (rc != RC_OK)
{
fat_shutdown_drive(temp_mt_entry);
ffc13610: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc13614: 48 00 56 99 bl ffc18cac <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info);
ffc13618: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1361c: 4b ff 4e c5 bl ffc084e0 <free> <== NOT EXECUTED
temp_mt_entry->mt_fs_root.node_access = fat_fd;
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
temp_mt_entry->mt_fs_root.ops = op_table;
return rc;
}
ffc13620: 80 01 00 4c lwz r0,76(r1) <== NOT EXECUTED
ffc13624: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc13628: 83 21 00 2c lwz r25,44(r1) <== NOT EXECUTED
ffc1362c: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc13630: 83 41 00 30 lwz r26,48(r1) <== NOT EXECUTED
ffc13634: 83 61 00 34 lwz r27,52(r1) <== NOT EXECUTED
ffc13638: 83 81 00 38 lwz r28,56(r1) <== NOT EXECUTED
ffc1363c: 83 a1 00 3c lwz r29,60(r1) <== NOT EXECUTED
ffc13640: 83 c1 00 40 lwz r30,64(r1) <== NOT EXECUTED
ffc13644: 83 e1 00 44 lwz r31,68(r1) <== NOT EXECUTED
ffc13648: 38 21 00 48 addi r1,r1,72 <== NOT EXECUTED
ffc1364c: 4e 80 00 20 blr <== NOT EXECUTED
/* if we have FAT12/16 */
if ( fat_fd->cln == 0 )
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
ffc13650: 7c 03 03 78 mr r3,r0
ffc13654: 4b ff ff 48 b ffc1359c <msdos_initialize_support+0xdc>
fs_info->fat.vol.bpc :
fs_info->fat.vol.rdir_size;
}
else
{
rc = fat_file_size(temp_mt_entry, fat_fd);
ffc13658: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1365c: 48 00 4b 49 bl ffc181a4 <fat_file_size> <== NOT EXECUTED
if ( rc != RC_OK )
ffc13660: 7c 7a 1b 79 mr. r26,r3 <== NOT EXECUTED
ffc13664: 40 82 00 0c bne- ffc13670 <msdos_initialize_support+0x1b0><== NOT EXECUTED
fat_file_close(temp_mt_entry, fat_fd);
fat_shutdown_drive(temp_mt_entry);
free(fs_info);
return rc;
}
cl_buf_size = fs_info->fat.vol.bpc;
ffc13668: a0 7f 00 06 lhz r3,6(r31) <== NOT EXECUTED
ffc1366c: 4b ff ff 30 b ffc1359c <msdos_initialize_support+0xdc><== NOT EXECUTED
else
{
rc = fat_file_size(temp_mt_entry, fat_fd);
if ( rc != RC_OK )
{
fat_file_close(temp_mt_entry, fat_fd);
ffc13670: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
ffc13674: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
fat_shutdown_drive(temp_mt_entry);
free(fs_info);
return rc;
ffc13678: 7f 5d d3 78 mr r29,r26 <== NOT EXECUTED
else
{
rc = fat_file_size(temp_mt_entry, fat_fd);
if ( rc != RC_OK )
{
fat_file_close(temp_mt_entry, fat_fd);
ffc1367c: 48 00 42 05 bl ffc17880 <fat_file_close> <== NOT EXECUTED
fat_shutdown_drive(temp_mt_entry);
ffc13680: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc13684: 48 00 56 29 bl ffc18cac <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info);
ffc13688: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1368c: 4b ff 4e 55 bl ffc084e0 <free> <== NOT EXECUTED
return rc;
ffc13690: 4b ff ff 90 b ffc13620 <msdos_initialize_support+0x160><== NOT EXECUTED
}
fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));
if (fs_info->cl_buf == NULL)
{
fat_file_close(temp_mt_entry, fat_fd);
ffc13694: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
ffc13698: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1369c: 48 00 41 e5 bl ffc17880 <fat_file_close> <== NOT EXECUTED
fat_shutdown_drive(temp_mt_entry);
ffc136a0: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc136a4: 48 00 56 09 bl ffc18cac <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info);
ffc136a8: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc136ac: 4b ff 4e 35 bl ffc084e0 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
ffc136b0: 48 01 0b 61 bl ffc24210 <__errno> <== NOT EXECUTED
ffc136b4: 38 00 00 0c li r0,12 <== NOT EXECUTED
ffc136b8: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc136bc: 3b a0 ff ff li r29,-1 <== NOT EXECUTED
ffc136c0: 4b ff ff 60 b ffc13620 <msdos_initialize_support+0x160><== NOT EXECUTED
RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO,
0,
&fs_info->vol_sema);
if (sc != RTEMS_SUCCESSFUL)
{
fat_file_close(temp_mt_entry, fat_fd);
ffc136c4: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
ffc136c8: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
fat_shutdown_drive(temp_mt_entry);
free(fs_info->cl_buf);
free(fs_info);
rtems_set_errno_and_return_minus_one( EIO );
ffc136cc: 3b a0 ff ff li r29,-1 <== NOT EXECUTED
RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO,
0,
&fs_info->vol_sema);
if (sc != RTEMS_SUCCESSFUL)
{
fat_file_close(temp_mt_entry, fat_fd);
ffc136d0: 48 00 41 b1 bl ffc17880 <fat_file_close> <== NOT EXECUTED
fat_shutdown_drive(temp_mt_entry);
ffc136d4: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc136d8: 48 00 55 d5 bl ffc18cac <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info->cl_buf);
ffc136dc: 80 7f 00 9c lwz r3,156(r31) <== NOT EXECUTED
ffc136e0: 4b ff 4e 01 bl ffc084e0 <free> <== NOT EXECUTED
free(fs_info);
ffc136e4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc136e8: 4b ff 4d f9 bl ffc084e0 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
ffc136ec: 48 01 0b 25 bl ffc24210 <__errno> <== NOT EXECUTED
ffc136f0: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc136f4: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc136f8: 4b ff ff 28 b ffc13620 <msdos_initialize_support+0x160><== NOT EXECUTED
ffc1f8f0 <msdos_is_valid_name_char>:
* MSDOS_NAME_LONG - Valid in a long name only.
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
ffc1f8f0: 94 21 ff f0 stwu r1,-16(r1)
ffc1f8f4: 7c 08 02 a6 mflr r0
ffc1f8f8: 93 e1 00 0c stw r31,12(r1)
ffc1f8fc: 7c 7f 1b 78 mr r31,r3
if (strchr(" +,;=[]", ch) != NULL)
ffc1f900: 3c 60 ff c3 lis r3,-61
ffc1f904: 38 63 55 58 addi r3,r3,21848
* MSDOS_NAME_LONG - Valid in a long name only.
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
ffc1f908: 90 01 00 14 stw r0,20(r1)
if (strchr(" +,;=[]", ch) != NULL)
ffc1f90c: 7f e4 fb 78 mr r4,r31
ffc1f910: 48 00 5c d1 bl ffc255e0 <strchr>
ffc1f914: 2f 83 00 00 cmpwi cr7,r3,0
return MSDOS_NAME_LONG;
ffc1f918: 38 60 00 02 li r3,2
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
ffc1f91c: 41 9e 00 18 beq- cr7,ffc1f934 <msdos_is_valid_name_char+0x44><== ALWAYS TAKEN
if ((ch == '.') || isalnum((unsigned char)ch) ||
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
return MSDOS_NAME_SHORT;
return MSDOS_NAME_INVALID;
}
ffc1f920: 80 01 00 14 lwz r0,20(r1)
ffc1f924: 83 e1 00 0c lwz r31,12(r1)
ffc1f928: 38 21 00 10 addi r1,r1,16
ffc1f92c: 7c 08 03 a6 mtlr r0
ffc1f930: 4e 80 00 20 blr
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
ffc1f934: 2f 9f 00 2e cmpwi cr7,r31,46
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
return MSDOS_NAME_SHORT;
ffc1f938: 38 60 00 01 li r3,1
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
ffc1f93c: 41 be ff e4 beq- cr7,ffc1f920 <msdos_is_valid_name_char+0x30>
ffc1f940: 3d 20 00 00 lis r9,0
ffc1f944: 81 29 27 ec lwz r9,10220(r9)
ffc1f948: 7d 29 fa 14 add r9,r9,r31
ffc1f94c: 88 09 00 01 lbz r0,1(r9)
ffc1f950: 70 09 00 07 andi. r9,r0,7
ffc1f954: 40 a2 ff cc bne- ffc1f920 <msdos_is_valid_name_char+0x30>
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
ffc1f958: 3c 60 ff c3 lis r3,-61
ffc1f95c: 38 63 55 60 addi r3,r3,21856
ffc1f960: 7f e4 fb 78 mr r4,r31
ffc1f964: 48 00 5c 7d bl ffc255e0 <strchr>
return MSDOS_NAME_SHORT;
ffc1f968: 7c 63 00 34 cntlzw r3,r3
ffc1f96c: 54 63 d9 7e rlwinm r3,r3,27,5,31
ffc1f970: 68 63 00 01 xori r3,r3,1
ffc1f974: 4b ff ff ac b ffc1f920 <msdos_is_valid_name_char+0x30>
ffc1f978 <msdos_long_to_short>:
*
*/
#define MSDOS_L2S_PRINT 0
msdos_name_type_t
msdos_long_to_short(const char *lfn, int lfn_len, char* sfn, int sfn_len)
{
ffc1f978: 94 21 ff d0 stwu r1,-48(r1)
ffc1f97c: 7c 08 02 a6 mflr r0
ffc1f980: 93 a1 00 24 stw r29,36(r1)
ffc1f984: 7c bd 2b 78 mr r29,r5
ffc1f988: 93 c1 00 28 stw r30,40(r1)
ffc1f98c: 7c 9e 23 78 mr r30,r4
int i;
/*
* Fill with spaces. This is how a short directory entry is padded.
*/
memset (sfn, ' ', sfn_len);
ffc1f990: 38 80 00 20 li r4,32
*
*/
#define MSDOS_L2S_PRINT 0
msdos_name_type_t
msdos_long_to_short(const char *lfn, int lfn_len, char* sfn, int sfn_len)
{
ffc1f994: 93 e1 00 2c stw r31,44(r1)
ffc1f998: 7c 7f 1b 78 mr r31,r3
int i;
/*
* Fill with spaces. This is how a short directory entry is padded.
*/
memset (sfn, ' ', sfn_len);
ffc1f99c: 7c a3 2b 78 mr r3,r5
ffc1f9a0: 7c c5 33 78 mr r5,r6
*
*/
#define MSDOS_L2S_PRINT 0
msdos_name_type_t
msdos_long_to_short(const char *lfn, int lfn_len, char* sfn, int sfn_len)
{
ffc1f9a4: 93 61 00 1c stw r27,28(r1)
ffc1f9a8: 90 01 00 34 stw r0,52(r1)
ffc1f9ac: 92 e1 00 0c stw r23,12(r1)
ffc1f9b0: 93 01 00 10 stw r24,16(r1)
ffc1f9b4: 93 21 00 14 stw r25,20(r1)
ffc1f9b8: 93 41 00 18 stw r26,24(r1)
ffc1f9bc: 93 81 00 20 stw r28,32(r1)
int i;
/*
* Fill with spaces. This is how a short directory entry is padded.
*/
memset (sfn, ' ', sfn_len);
ffc1f9c0: 48 00 57 69 bl ffc25128 <memset>
/*
* Handle '.' and '..' specially.
*/
if ((lfn[0] == '.') && (lfn_len == 1))
ffc1f9c4: 8b 7f 00 00 lbz r27,0(r31)
ffc1f9c8: 2f 9b 00 2e cmpwi cr7,r27,46
ffc1f9cc: 41 9e 01 ac beq- cr7,ffc1fb78 <msdos_long_to_short+0x200>
}
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
ffc1f9d0: 2c 9e 00 00 cmpwi cr1,r30,0
ffc1f9d4: 7f c9 03 a6 mtctr r30
ffc1f9d8: 39 20 00 00 li r9,0
ffc1f9dc: 40 85 00 5c ble- cr1,ffc1fa38 <msdos_long_to_short+0xc0><== NEVER TAKEN
if ((lfn[i] != ' ') && (lfn[i] != '.'))
ffc1f9e0: 7c 1f 48 ae lbzx r0,r31,r9
}
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
ffc1f9e4: 39 29 00 01 addi r9,r9,1
if ((lfn[i] != ' ') && (lfn[i] != '.'))
ffc1f9e8: 2f 80 00 20 cmpwi cr7,r0,32
ffc1f9ec: 2f 00 00 2e cmpwi cr6,r0,46
ffc1f9f0: 41 9e 00 08 beq- cr7,ffc1f9f8 <msdos_long_to_short+0x80><== NEVER TAKEN
ffc1f9f4: 40 9a 00 48 bne- cr6,ffc1fa3c <msdos_long_to_short+0xc4><== ALWAYS TAKEN
}
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
ffc1f9f8: 42 00 ff e8 bdnz+ ffc1f9e0 <msdos_long_to_short+0x68> <== NOT EXECUTED
if (i == lfn_len)
{
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: INVALID[1]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_INVALID;
ffc1f9fc: 3b 80 00 00 li r28,0 <== NOT EXECUTED
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif
return type;
}
ffc1fa00: 80 01 00 34 lwz r0,52(r1)
ffc1fa04: 7f 83 e3 78 mr r3,r28
ffc1fa08: 82 e1 00 0c lwz r23,12(r1)
ffc1fa0c: 7c 08 03 a6 mtlr r0
ffc1fa10: 83 01 00 10 lwz r24,16(r1)
ffc1fa14: 83 21 00 14 lwz r25,20(r1)
ffc1fa18: 83 41 00 18 lwz r26,24(r1)
ffc1fa1c: 83 61 00 1c lwz r27,28(r1)
ffc1fa20: 83 81 00 20 lwz r28,32(r1)
ffc1fa24: 83 a1 00 24 lwz r29,36(r1)
ffc1fa28: 83 c1 00 28 lwz r30,40(r1)
ffc1fa2c: 83 e1 00 2c lwz r31,44(r1)
ffc1fa30: 38 21 00 30 addi r1,r1,48
ffc1fa34: 4e 80 00 20 blr
*/
for (i = 0; i < lfn_len; i++)
if ((lfn[i] != ' ') && (lfn[i] != '.'))
break;
if (i == lfn_len)
ffc1fa38: 41 a6 ff c4 beq- cr1,ffc1f9fc <msdos_long_to_short+0x84><== NOT EXECUTED
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
ffc1fa3c: 2f 9b 00 00 cmpwi cr7,r27,0
ffc1fa40: 41 9e 01 64 beq- cr7,ffc1fba4 <msdos_long_to_short+0x22c><== NEVER TAKEN
ffc1fa44: 40 85 01 60 ble- cr1,ffc1fba4 <msdos_long_to_short+0x22c><== NEVER TAKEN
ffc1fa48: 3b 00 00 00 li r24,0
ffc1fa4c: 3a e0 00 00 li r23,0
ffc1fa50: 3b 40 00 00 li r26,0
ffc1fa54: 3b 20 ff ff li r25,-1
ffc1fa58: 48 00 00 58 b ffc1fab0 <msdos_long_to_short+0x138>
if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
return type;
if (dot_at >= 0)
{
if (is_dot || ((count - dot_at) > 3))
ffc1fa5c: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc1fa60: 40 9e 01 4c bne- cr7,ffc1fbac <msdos_long_to_short+0x234><== NOT EXECUTED
ffc1fa64: 7c 19 d0 50 subf r0,r25,r26 <== NOT EXECUTED
ffc1fa68: 2f 80 00 03 cmpwi cr7,r0,3 <== NOT EXECUTED
ffc1fa6c: 41 9d 01 40 bgt- cr7,ffc1fbac <msdos_long_to_short+0x234><== NOT EXECUTED
}
}
if (is_dot)
dot_at = count;
else if ((*name >= 'A') && (*name <= 'Z'))
ffc1fa70: 38 1b ff bf addi r0,r27,-65
ffc1fa74: 54 00 06 3e clrlwi r0,r0,24
ffc1fa78: 2b 80 00 19 cmplwi cr7,r0,25
ffc1fa7c: 40 9d 00 e4 ble- cr7,ffc1fb60 <msdos_long_to_short+0x1e8><== NEVER TAKEN
uppercase = true;
else if ((*name >= 'a') && (*name <= 'z'))
ffc1fa80: 3b 7b ff 9f addi r27,r27,-97
ffc1fa84: 57 7b 06 3e clrlwi r27,r27,24
ffc1fa88: 2b 9b 00 19 cmplwi cr7,r27,25
ffc1fa8c: 41 9d 00 08 bgt- cr7,ffc1fa94 <msdos_long_to_short+0x11c>
lowercase = true;
ffc1fa90: 3a e0 00 01 li r23,1
* true the name is long, else the name is short.
*
*/
#define MSDOS_L2S_PRINT 0
msdos_name_type_t
msdos_long_to_short(const char *lfn, int lfn_len, char* sfn, int sfn_len)
ffc1fa94: 7d 3f d2 14 add r9,r31,r26
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
ffc1fa98: 8b 69 00 01 lbz r27,1(r9)
ffc1fa9c: 2f 9b 00 00 cmpwi cr7,r27,0
ffc1faa0: 41 9e 00 60 beq- cr7,ffc1fb00 <msdos_long_to_short+0x188>
else if ((*name >= 'A') && (*name <= 'Z'))
uppercase = true;
else if ((*name >= 'a') && (*name <= 'z'))
lowercase = true;
count++;
ffc1faa4: 3b 5a 00 01 addi r26,r26,1
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
ffc1faa8: 7f 9a f0 00 cmpw cr7,r26,r30
ffc1faac: 41 9e 00 54 beq- cr7,ffc1fb00 <msdos_long_to_short+0x188>
{
bool is_dot = *name == '.';
msdos_name_type_t type = msdos_is_valid_name_char(*name);
ffc1fab0: 7f 63 db 78 mr r3,r27
ffc1fab4: 4b ff fe 3d bl ffc1f8f0 <msdos_is_valid_name_char>
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: c:%02x type:%d\n", *name, type);
#endif
if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
ffc1fab8: 7c 7c 1b 79 mr. r28,r3
ffc1fabc: 41 a2 ff 44 beq- ffc1fa00 <msdos_long_to_short+0x88>
ffc1fac0: 2f 9c 00 02 cmpwi cr7,r28,2
ffc1fac4: 41 9e 00 54 beq- cr7,ffc1fb18 <msdos_long_to_short+0x1a0><== NEVER TAKEN
return type;
if (dot_at >= 0)
ffc1fac8: 2f 99 ff ff cmpwi cr7,r25,-1
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
ffc1facc: 6b 60 00 2e xori r0,r27,46
ffc1fad0: 7c 00 00 34 cntlzw r0,r0
ffc1fad4: 54 00 d9 7e rlwinm r0,r0,27,5,31
#endif
if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
return type;
if (dot_at >= 0)
ffc1fad8: 40 9e ff 84 bne+ cr7,ffc1fa5c <msdos_long_to_short+0xe4><== NEVER TAKEN
return MSDOS_NAME_LONG;
}
}
else
{
if (count == 8 && !is_dot)
ffc1fadc: 2f 9a 00 08 cmpwi cr7,r26,8
ffc1fae0: 41 9e 00 88 beq- cr7,ffc1fb68 <msdos_long_to_short+0x1f0>
#endif
return MSDOS_NAME_LONG;
}
}
if (is_dot)
ffc1fae4: 2f 80 00 00 cmpwi cr7,r0,0
ffc1fae8: 41 be ff 88 beq- cr7,ffc1fa70 <msdos_long_to_short+0xf8><== ALWAYS TAKEN
* true the name is long, else the name is short.
*
*/
#define MSDOS_L2S_PRINT 0
msdos_name_type_t
msdos_long_to_short(const char *lfn, int lfn_len, char* sfn, int sfn_len)
ffc1faec: 7d 3f d2 14 add r9,r31,r26 <== NOT EXECUTED
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
ffc1faf0: 8b 69 00 01 lbz r27,1(r9) <== NOT EXECUTED
#endif
return MSDOS_NAME_LONG;
}
}
if (is_dot)
ffc1faf4: 7f 59 d3 78 mr r25,r26 <== NOT EXECUTED
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
ffc1faf8: 2f 9b 00 00 cmpwi cr7,r27,0 <== NOT EXECUTED
ffc1fafc: 40 9e ff a8 bne+ cr7,ffc1faa4 <msdos_long_to_short+0x12c><== NOT EXECUTED
count++;
name++;
}
if (lowercase && uppercase)
ffc1fb00: 2f 97 00 00 cmpwi cr7,r23,0
}
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: SHORT[1]\n");
#endif
return MSDOS_NAME_SHORT;
ffc1fb04: 3b 80 00 01 li r28,1
count++;
name++;
}
if (lowercase && uppercase)
ffc1fb08: 41 9e 00 10 beq- cr7,ffc1fb18 <msdos_long_to_short+0x1a0><== NEVER TAKEN
ffc1fb0c: 2f 98 00 00 cmpwi cr7,r24,0
{
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: LONG[3]\n");
#endif
return MSDOS_NAME_LONG;
ffc1fb10: 3b 80 00 02 li r28,2
count++;
name++;
}
if (lowercase && uppercase)
ffc1fb14: 41 9e 00 90 beq- cr7,ffc1fba4 <msdos_long_to_short+0x22c><== ALWAYS TAKEN
printf ("MSDOS_L2S: INVALID[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_INVALID;
}
msdos_filename_unix2dos (lfn, lfn_len, sfn);
ffc1fb18: 7f e3 fb 78 mr r3,r31
ffc1fb1c: 7f c4 f3 78 mr r4,r30
ffc1fb20: 7f a5 eb 78 mr r5,r29
ffc1fb24: 48 00 3a 11 bl ffc23534 <msdos_filename_unix2dos>
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif
return type;
}
ffc1fb28: 80 01 00 34 lwz r0,52(r1)
ffc1fb2c: 7f 83 e3 78 mr r3,r28
ffc1fb30: 82 e1 00 0c lwz r23,12(r1)
ffc1fb34: 7c 08 03 a6 mtlr r0
ffc1fb38: 83 01 00 10 lwz r24,16(r1)
ffc1fb3c: 83 21 00 14 lwz r25,20(r1)
ffc1fb40: 83 41 00 18 lwz r26,24(r1)
ffc1fb44: 83 61 00 1c lwz r27,28(r1)
ffc1fb48: 83 81 00 20 lwz r28,32(r1)
ffc1fb4c: 83 a1 00 24 lwz r29,36(r1)
ffc1fb50: 83 c1 00 28 lwz r30,40(r1)
ffc1fb54: 83 e1 00 2c lwz r31,44(r1)
ffc1fb58: 38 21 00 30 addi r1,r1,48
ffc1fb5c: 4e 80 00 20 blr
}
if (is_dot)
dot_at = count;
else if ((*name >= 'A') && (*name <= 'Z'))
uppercase = true;
ffc1fb60: 3b 00 00 01 li r24,1 <== NOT EXECUTED
ffc1fb64: 4b ff ff 30 b ffc1fa94 <msdos_long_to_short+0x11c> <== NOT EXECUTED
return MSDOS_NAME_LONG;
}
}
else
{
if (count == 8 && !is_dot)
ffc1fb68: 2f 80 00 00 cmpwi cr7,r0,0
ffc1fb6c: 41 9e 00 40 beq- cr7,ffc1fbac <msdos_long_to_short+0x234><== ALWAYS TAKEN
ffc1fb70: 3b 20 00 08 li r25,8 <== NOT EXECUTED
ffc1fb74: 4b ff ff 20 b ffc1fa94 <msdos_long_to_short+0x11c> <== NOT EXECUTED
memset (sfn, ' ', sfn_len);
/*
* Handle '.' and '..' specially.
*/
if ((lfn[0] == '.') && (lfn_len == 1))
ffc1fb78: 2f 9e 00 01 cmpwi cr7,r30,1
ffc1fb7c: 41 9e 00 48 beq- cr7,ffc1fbc4 <msdos_long_to_short+0x24c><== NEVER TAKEN
printf ("MSDOS_L2S: SHORT[1]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_SHORT;
}
if ((lfn[0] == '.') && (lfn[1] == '.') && (lfn_len == 2))
ffc1fb80: 88 1f 00 01 lbz r0,1(r31)
ffc1fb84: 2f 80 00 2e cmpwi cr7,r0,46
ffc1fb88: 40 9e fe 48 bne+ cr7,ffc1f9d0 <msdos_long_to_short+0x58><== NEVER TAKEN
ffc1fb8c: 2f 9e 00 02 cmpwi cr7,r30,2
ffc1fb90: 40 9e fe 40 bne+ cr7,ffc1f9d0 <msdos_long_to_short+0x58><== NEVER TAKEN
{
sfn[0] = sfn[1] = '.';
ffc1fb94: 98 1d 00 01 stb r0,1(r29)
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: SHORT[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_SHORT;
ffc1fb98: 3b 80 00 01 li r28,1
return MSDOS_NAME_SHORT;
}
if ((lfn[0] == '.') && (lfn[1] == '.') && (lfn_len == 2))
{
sfn[0] = sfn[1] = '.';
ffc1fb9c: 98 1d 00 00 stb r0,0(r29)
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: SHORT[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_SHORT;
ffc1fba0: 4b ff fe 60 b ffc1fa00 <msdos_long_to_short+0x88>
}
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: SHORT[1]\n");
#endif
return MSDOS_NAME_SHORT;
ffc1fba4: 3b 80 00 01 li r28,1
ffc1fba8: 4b ff ff 70 b ffc1fb18 <msdos_long_to_short+0x1a0>
printf ("MSDOS_L2S: INVALID[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_INVALID;
}
msdos_filename_unix2dos (lfn, lfn_len, sfn);
ffc1fbac: 7f e3 fb 78 mr r3,r31
ffc1fbb0: 7f c4 f3 78 mr r4,r30
ffc1fbb4: 7f a5 eb 78 mr r5,r29
{
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: LONG[2]: is_dot:%d, at:%d cnt\n",
is_dot, dot_at, count);
#endif
return MSDOS_NAME_LONG;
ffc1fbb8: 3b 80 00 02 li r28,2
printf ("MSDOS_L2S: INVALID[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_INVALID;
}
msdos_filename_unix2dos (lfn, lfn_len, sfn);
ffc1fbbc: 48 00 39 79 bl ffc23534 <msdos_filename_unix2dos>
ffc1fbc0: 4b ff ff 68 b ffc1fb28 <msdos_long_to_short+0x1b0>
/*
* Handle '.' and '..' specially.
*/
if ((lfn[0] == '.') && (lfn_len == 1))
{
sfn[0] = '.';
ffc1fbc4: 9b 7d 00 00 stb r27,0(r29) <== NOT EXECUTED
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: SHORT[1]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_SHORT;
ffc1fbc8: 3b 80 00 01 li r28,1 <== NOT EXECUTED
ffc1fbcc: 4b ff fe 34 b ffc1fa00 <msdos_long_to_short+0x88> <== NOT EXECUTED
ffc136fc <msdos_mknod>:
const char *name,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
ffc136fc: 94 21 ff e0 stwu r1,-32(r1)
ffc13700: 7c 08 02 a6 mflr r0
ffc13704: 90 01 00 24 stw r0,36(r1)
msdos_token_types_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
ffc13708: 54 80 04 26 rlwinm r0,r4,0,16,19
ffc1370c: 2f 80 40 00 cmpwi cr7,r0,16384
rtems_filesystem_location_info_t *pathloc
)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
ffc13710: 81 27 00 10 lwz r9,16(r7)
const char *name,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
ffc13714: 93 81 00 10 stw r28,16(r1)
ffc13718: 7c 7c 1b 78 mr r28,r3
ffc1371c: 93 a1 00 14 stw r29,20(r1)
ffc13720: 7c fd 3b 78 mr r29,r7
ffc13724: 93 c1 00 18 stw r30,24(r1)
ffc13728: 7c 9e 23 78 mr r30,r4
ffc1372c: 93 e1 00 1c stw r31,28(r1)
ffc13730: 93 61 00 0c stw r27,12(r1)
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
ffc13734: 83 e9 00 34 lwz r31,52(r9)
msdos_token_types_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
ffc13738: 41 9e 00 88 beq- cr7,ffc137c0 <msdos_mknod+0xc4>
{
type = MSDOS_DIRECTORY;
}
else if (S_ISREG(mode))
ffc1373c: 39 20 00 00 li r9,0
ffc13740: 61 29 80 00 ori r9,r9,32768
ffc13744: 7f 80 48 00 cmpw cr7,r0,r9
{
type = MSDOS_REGULAR_FILE;
ffc13748: 3b 60 00 05 li r27,5
*/
if (S_ISDIR(mode))
{
type = MSDOS_DIRECTORY;
}
else if (S_ISREG(mode))
ffc1374c: 40 9e 00 90 bne- cr7,ffc137dc <msdos_mknod+0xe0> <== NEVER TAKEN
type = MSDOS_REGULAR_FILE;
}
else
rtems_set_errno_and_return_minus_one(EINVAL);
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc13750: 80 7f 00 98 lwz r3,152(r31)
ffc13754: 38 80 00 00 li r4,0
ffc13758: 38 a0 00 00 li r5,0
ffc1375c: 4b ff a0 31 bl ffc0d78c <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc13760: 2f 83 00 00 cmpwi cr7,r3,0
ffc13764: 40 9e 00 64 bne- cr7,ffc137c8 <msdos_mknod+0xcc> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one(EIO);
/* Create an MSDOS node */
rc = msdos_creat_node(pathloc, type, name, strlen(name), mode, NULL);
ffc13768: 7f 83 e3 78 mr r3,r28
ffc1376c: 48 01 26 21 bl ffc25d8c <strlen>
ffc13770: 7f c7 f3 78 mr r7,r30
ffc13774: 7c 66 1b 78 mr r6,r3
ffc13778: 7f 64 db 78 mr r4,r27
ffc1377c: 7f a3 eb 78 mr r3,r29
ffc13780: 7f 85 e3 78 mr r5,r28
ffc13784: 39 00 00 00 li r8,0
ffc13788: 48 00 ad 49 bl ffc1e4d0 <msdos_creat_node>
ffc1378c: 7c 7e 1b 78 mr r30,r3
rtems_semaphore_release(fs_info->vol_sema);
ffc13790: 80 7f 00 98 lwz r3,152(r31)
ffc13794: 4b ff a1 85 bl ffc0d918 <rtems_semaphore_release>
return rc;
}
ffc13798: 80 01 00 24 lwz r0,36(r1)
ffc1379c: 7f c3 f3 78 mr r3,r30
ffc137a0: 83 61 00 0c lwz r27,12(r1)
ffc137a4: 7c 08 03 a6 mtlr r0
ffc137a8: 83 81 00 10 lwz r28,16(r1)
ffc137ac: 83 a1 00 14 lwz r29,20(r1)
ffc137b0: 83 c1 00 18 lwz r30,24(r1)
ffc137b4: 83 e1 00 1c lwz r31,28(r1)
ffc137b8: 38 21 00 20 addi r1,r1,32
ffc137bc: 4e 80 00 20 blr
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
{
type = MSDOS_DIRECTORY;
ffc137c0: 3b 60 00 01 li r27,1
ffc137c4: 4b ff ff 8c b ffc13750 <msdos_mknod+0x54>
rtems_set_errno_and_return_minus_one(EINVAL);
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
ffc137c8: 48 01 0a 49 bl ffc24210 <__errno> <== NOT EXECUTED
ffc137cc: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc137d0: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc137d4: 3b c0 ff ff li r30,-1 <== NOT EXECUTED
ffc137d8: 4b ff ff c0 b ffc13798 <msdos_mknod+0x9c> <== NOT EXECUTED
else if (S_ISREG(mode))
{
type = MSDOS_REGULAR_FILE;
}
else
rtems_set_errno_and_return_minus_one(EINVAL);
ffc137dc: 48 01 0a 35 bl ffc24210 <__errno> <== NOT EXECUTED
ffc137e0: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc137e4: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc137e8: 3b c0 ff ff li r30,-1 <== NOT EXECUTED
ffc137ec: 4b ff ff ac b ffc13798 <msdos_mknod+0x9c> <== NOT EXECUTED
ffc137fc <msdos_rename>:
int
msdos_rename(rtems_filesystem_location_info_t *old_parent_loc,
rtems_filesystem_location_info_t *old_loc,
rtems_filesystem_location_info_t *new_parent_loc,
const char *new_name)
{
ffc137fc: 94 21 ff d0 stwu r1,-48(r1) <== NOT EXECUTED
ffc13800: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
int len;
/*
* check spelling and format new node name
*/
if (MSDOS_NAME != msdos_get_token(new_name, strlen(new_name), &token, &len)) {
ffc13804: 7c c3 33 78 mr r3,r6 <== NOT EXECUTED
int
msdos_rename(rtems_filesystem_location_info_t *old_parent_loc,
rtems_filesystem_location_info_t *old_loc,
rtems_filesystem_location_info_t *new_parent_loc,
const char *new_name)
{
ffc13808: 90 01 00 34 stw r0,52(r1) <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = new_parent_loc->mt_entry->fs_info;
ffc1380c: 81 25 00 10 lwz r9,16(r5) <== NOT EXECUTED
int
msdos_rename(rtems_filesystem_location_info_t *old_parent_loc,
rtems_filesystem_location_info_t *old_loc,
rtems_filesystem_location_info_t *new_parent_loc,
const char *new_name)
{
ffc13810: 93 61 00 1c stw r27,28(r1) <== NOT EXECUTED
ffc13814: 7c bb 2b 78 mr r27,r5 <== NOT EXECUTED
ffc13818: 93 81 00 20 stw r28,32(r1) <== NOT EXECUTED
ffc1381c: 7c dc 33 78 mr r28,r6 <== NOT EXECUTED
ffc13820: 93 a1 00 24 stw r29,36(r1) <== NOT EXECUTED
ffc13824: 93 c1 00 28 stw r30,40(r1) <== NOT EXECUTED
ffc13828: 7c 9e 23 78 mr r30,r4 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = new_parent_loc->mt_entry->fs_info;
fat_file_fd_t *old_fat_fd = old_loc->node_access;
ffc1382c: 83 a4 00 00 lwz r29,0(r4) <== NOT EXECUTED
int
msdos_rename(rtems_filesystem_location_info_t *old_parent_loc,
rtems_filesystem_location_info_t *old_loc,
rtems_filesystem_location_info_t *new_parent_loc,
const char *new_name)
{
ffc13830: 93 e1 00 2c stw r31,44(r1) <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = new_parent_loc->mt_entry->fs_info;
ffc13834: 83 e9 00 34 lwz r31,52(r9) <== NOT EXECUTED
int len;
/*
* check spelling and format new node name
*/
if (MSDOS_NAME != msdos_get_token(new_name, strlen(new_name), &token, &len)) {
ffc13838: 48 01 25 55 bl ffc25d8c <strlen> <== NOT EXECUTED
ffc1383c: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc13840: 38 a1 00 0c addi r5,r1,12 <== NOT EXECUTED
ffc13844: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc13848: 38 c1 00 08 addi r6,r1,8 <== NOT EXECUTED
ffc1384c: 48 00 c3 85 bl ffc1fbd0 <msdos_get_token> <== NOT EXECUTED
ffc13850: 2f 83 00 03 cmpwi cr7,r3,3 <== NOT EXECUTED
ffc13854: 40 9e 00 88 bne- cr7,ffc138dc <msdos_rename+0xe0> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENAMETOOLONG);
}
/*
* lock volume
*/
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc13858: 80 7f 00 98 lwz r3,152(r31) <== NOT EXECUTED
ffc1385c: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc13860: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc13864: 4b ff 9f 29 bl ffc0d78c <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc13868: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1386c: 40 9e 00 84 bne- cr7,ffc138f0 <msdos_rename+0xf4> <== NOT EXECUTED
/*
* create new directory entry as "hard link", copying relevant info from
* existing file
*/
rc = msdos_creat_node(new_parent_loc,
ffc13870: 80 c1 00 08 lwz r6,8(r1) <== NOT EXECUTED
ffc13874: 38 e0 00 00 li r7,0 <== NOT EXECUTED
ffc13878: 7f 85 e3 78 mr r5,r28 <== NOT EXECUTED
ffc1387c: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc13880: 38 80 00 03 li r4,3 <== NOT EXECUTED
ffc13884: 60 e7 80 00 ori r7,r7,32768 <== NOT EXECUTED
ffc13888: 7f a8 eb 78 mr r8,r29 <== NOT EXECUTED
ffc1388c: 48 00 ac 45 bl ffc1e4d0 <msdos_creat_node> <== NOT EXECUTED
MSDOS_HARD_LINK,new_name,len,S_IFREG,
old_fat_fd);
if (rc != RC_OK)
ffc13890: 7c 7c 1b 79 mr. r28,r3 <== NOT EXECUTED
ffc13894: 40 82 00 18 bne- ffc138ac <msdos_rename+0xb0> <== NOT EXECUTED
}
/*
* mark file removed
*/
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
ffc13898: 80 7e 00 10 lwz r3,16(r30) <== NOT EXECUTED
ffc1389c: 38 9d 00 20 addi r4,r29,32 <== NOT EXECUTED
ffc138a0: 38 a0 00 e5 li r5,229 <== NOT EXECUTED
ffc138a4: 48 00 c7 85 bl ffc20028 <msdos_set_first_char4file_name><== NOT EXECUTED
ffc138a8: 7c 7c 1b 78 mr r28,r3 <== NOT EXECUTED
&old_fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
rtems_semaphore_release(fs_info->vol_sema);
ffc138ac: 80 7f 00 98 lwz r3,152(r31) <== NOT EXECUTED
ffc138b0: 4b ff a0 69 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
return rc;
}
ffc138b4: 80 01 00 34 lwz r0,52(r1) <== NOT EXECUTED
ffc138b8: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc138bc: 83 61 00 1c lwz r27,28(r1) <== NOT EXECUTED
ffc138c0: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc138c4: 83 81 00 20 lwz r28,32(r1) <== NOT EXECUTED
ffc138c8: 83 a1 00 24 lwz r29,36(r1) <== NOT EXECUTED
ffc138cc: 83 c1 00 28 lwz r30,40(r1) <== NOT EXECUTED
ffc138d0: 83 e1 00 2c lwz r31,44(r1) <== NOT EXECUTED
ffc138d4: 38 21 00 30 addi r1,r1,48 <== NOT EXECUTED
ffc138d8: 4e 80 00 20 blr <== NOT EXECUTED
/*
* check spelling and format new node name
*/
if (MSDOS_NAME != msdos_get_token(new_name, strlen(new_name), &token, &len)) {
rtems_set_errno_and_return_minus_one(ENAMETOOLONG);
ffc138dc: 48 01 09 35 bl ffc24210 <__errno> <== NOT EXECUTED
ffc138e0: 38 00 00 5b li r0,91 <== NOT EXECUTED
ffc138e4: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc138e8: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
ffc138ec: 4b ff ff c8 b ffc138b4 <msdos_rename+0xb8> <== NOT EXECUTED
* lock volume
*/
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
ffc138f0: 48 01 09 21 bl ffc24210 <__errno> <== NOT EXECUTED
ffc138f4: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc138f8: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc138fc: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
ffc13900: 4b ff ff b4 b ffc138b4 <msdos_rename+0xb8> <== NOT EXECUTED
ffc1fd28 <msdos_set_dir_wrt_time_and_date>:
int
msdos_set_dir_wrt_time_and_date(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ffc1fd28: 94 21 ff d0 stwu r1,-48(r1)
ffc1fd2c: 7c 08 02 a6 mflr r0
ffc1fd30: 90 01 00 34 stw r0,52(r1)
uint16_t time_val;
uint16_t date;
uint32_t sec = 0;
uint32_t byte = 0;
msdos_date_unix2dos(fat_fd->mtime, &date, &time_val);
ffc1fd34: 38 a1 00 0a addi r5,r1,10
int
msdos_set_dir_wrt_time_and_date(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ffc1fd38: 93 e1 00 2c stw r31,44(r1)
ffc1fd3c: 7c 7f 1b 78 mr r31,r3
uint16_t time_val;
uint16_t date;
uint32_t sec = 0;
uint32_t byte = 0;
msdos_date_unix2dos(fat_fd->mtime, &date, &time_val);
ffc1fd40: 80 64 00 40 lwz r3,64(r4)
int
msdos_set_dir_wrt_time_and_date(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ffc1fd44: 93 c1 00 28 stw r30,40(r1)
ffc1fd48: 7c 9e 23 78 mr r30,r4
uint16_t time_val;
uint16_t date;
uint32_t sec = 0;
uint32_t byte = 0;
msdos_date_unix2dos(fat_fd->mtime, &date, &time_val);
ffc1fd4c: 38 81 00 08 addi r4,r1,8
int
msdos_set_dir_wrt_time_and_date(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ffc1fd50: 93 81 00 20 stw r28,32(r1)
ffc1fd54: 93 61 00 1c stw r27,28(r1)
ffc1fd58: 93 a1 00 24 stw r29,36(r1)
ssize_t ret1 = 0, ret2 = 0, ret3 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
ffc1fd5c: 83 9f 00 34 lwz r28,52(r31)
uint16_t time_val;
uint16_t date;
uint32_t sec = 0;
uint32_t byte = 0;
msdos_date_unix2dos(fat_fd->mtime, &date, &time_val);
ffc1fd60: 48 00 35 55 bl ffc232b4 <msdos_date_unix2dos>
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
ffc1fd64: 81 7e 00 20 lwz r11,32(r30)
}
}
j++;
}
return MSDOS_NAME_NOT_FOUND_ERR;
}
ffc1fd68: 81 3f 00 34 lwz r9,52(r31)
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
ffc1fd6c: 2f 8b 00 00 cmpwi cr7,r11,0
ffc1fd70: 40 9e 00 10 bne- cr7,ffc1fd80 <msdos_set_dir_wrt_time_and_date+0x58><== ALWAYS TAKEN
ffc1fd74: 88 09 00 0a lbz r0,10(r9) <== NOT EXECUTED
ffc1fd78: 70 0a 00 03 andi. r10,r0,3 <== NOT EXECUTED
ffc1fd7c: 40 82 00 ec bne- ffc1fe68 <msdos_set_dir_wrt_time_and_date+0x140><== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
ffc1fd80: 89 49 00 05 lbz r10,5(r9)
ffc1fd84: 3b ab ff fe addi r29,r11,-2
ffc1fd88: 80 09 00 30 lwz r0,48(r9)
ffc1fd8c: 7f bd 50 30 slw r29,r29,r10
ffc1fd90: 7f bd 02 14 add r29,r29,r0
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
ffc1fd94: 80 1e 00 24 lwz r0,36(r30)
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
ffc1fd98: 38 c0 00 02 li r6,2
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
ffc1fd9c: a3 dc 00 00 lhz r30,0(r28)
time_val = CT_LE_W(time_val);
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
ffc1fda0: 38 e1 00 0a addi r7,r1,10
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
ffc1fda4: 89 5c 00 02 lbz r10,2(r28)
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
ffc1fda8: 7f e3 fb 78 mr r3,r31
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
ffc1fdac: a1 21 00 0a lhz r9,10(r1)
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
ffc1fdb0: 3b de ff ff addi r30,r30,-1
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
ffc1fdb4: 7c 0a 54 30 srw r10,r0,r10
ffc1fdb8: 7f bd 52 14 add r29,r29,r10
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
ffc1fdbc: 7f de 00 38 and r30,r30,r0
time_val = CT_LE_W(time_val);
ffc1fdc0: 55 20 40 2e rlwinm r0,r9,8,0,23
ffc1fdc4: 55 29 c2 3e rlwinm r9,r9,24,8,31
ffc1fdc8: 7c 00 4b 78 or r0,r0,r9
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
ffc1fdcc: 7f a4 eb 78 mr r4,r29
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
ffc1fdd0: b0 01 00 0a sth r0,10(r1)
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
ffc1fdd4: 38 be 00 16 addi r5,r30,22
ffc1fdd8: 4b ff 89 ad bl ffc18784 <_fat_block_write>
2, (char *)(&time_val));
date = CT_LE_W(date);
ffc1fddc: a1 21 00 08 lhz r9,8(r1)
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
ffc1fde0: 7c 7c 1b 78 mr r28,r3
2, (char *)(&time_val));
date = CT_LE_W(date);
ffc1fde4: 55 20 40 2e rlwinm r0,r9,8,0,23
ffc1fde8: 55 29 c2 3e rlwinm r9,r9,24,8,31
ffc1fdec: 7c 00 4b 78 or r0,r0,r9
ret2 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WDATE_OFFSET,
ffc1fdf0: 38 be 00 18 addi r5,r30,24
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2, (char *)(&time_val));
date = CT_LE_W(date);
ffc1fdf4: b0 01 00 08 sth r0,8(r1)
ret2 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WDATE_OFFSET,
ffc1fdf8: 38 c0 00 02 li r6,2
ffc1fdfc: 38 e1 00 08 addi r7,r1,8
ffc1fe00: 7f a4 eb 78 mr r4,r29
ffc1fe04: 7f e3 fb 78 mr r3,r31
ffc1fe08: 4b ff 89 7d bl ffc18784 <_fat_block_write>
2, (char *)(&date));
ret3 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_ADATE_OFFSET,
ffc1fe0c: 7f a4 eb 78 mr r4,r29
time_val = CT_LE_W(time_val);
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2, (char *)(&time_val));
date = CT_LE_W(date);
ret2 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WDATE_OFFSET,
ffc1fe10: 7c 7b 1b 78 mr r27,r3
2, (char *)(&date));
ret3 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_ADATE_OFFSET,
ffc1fe14: 38 be 00 12 addi r5,r30,18
ffc1fe18: 7f e3 fb 78 mr r3,r31
ffc1fe1c: 38 c0 00 02 li r6,2
ffc1fe20: 38 e1 00 08 addi r7,r1,8
ffc1fe24: 4b ff 89 61 bl ffc18784 <_fat_block_write>
2, (char *)(&date));
if ( (ret1 < 0) || (ret2 < 0) || (ret3 < 0) )
ffc1fe28: 2f 9c 00 00 cmpwi cr7,r28,0
return -1;
ffc1fe2c: 38 00 ff ff li r0,-1
ret2 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WDATE_OFFSET,
2, (char *)(&date));
ret3 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_ADATE_OFFSET,
2, (char *)(&date));
if ( (ret1 < 0) || (ret2 < 0) || (ret3 < 0) )
ffc1fe30: 41 9c 00 10 blt- cr7,ffc1fe40 <msdos_set_dir_wrt_time_and_date+0x118><== NEVER TAKEN
ffc1fe34: 2f 9b 00 00 cmpwi cr7,r27,0
ffc1fe38: 41 9c 00 08 blt- cr7,ffc1fe40 <msdos_set_dir_wrt_time_and_date+0x118><== NEVER TAKEN
return -1;
ffc1fe3c: 7c 60 fe 70 srawi r0,r3,31
return RC_OK;
}
ffc1fe40: 7c 03 03 78 mr r3,r0
ffc1fe44: 80 01 00 34 lwz r0,52(r1)
ffc1fe48: 83 61 00 1c lwz r27,28(r1)
ffc1fe4c: 7c 08 03 a6 mtlr r0
ffc1fe50: 83 81 00 20 lwz r28,32(r1)
ffc1fe54: 83 a1 00 24 lwz r29,36(r1)
ffc1fe58: 83 c1 00 28 lwz r30,40(r1)
ffc1fe5c: 83 e1 00 2c lwz r31,44(r1)
ffc1fe60: 38 21 00 30 addi r1,r1,48
ffc1fe64: 4e 80 00 20 blr
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
return fs_info->vol.rdir_loc;
ffc1fe68: 83 a9 00 1c lwz r29,28(r9) <== NOT EXECUTED
ffc1fe6c: 4b ff ff 28 b ffc1fd94 <msdos_set_dir_wrt_time_and_date+0x6c><== NOT EXECUTED
ffc1ff88 <msdos_set_file_size>:
int
msdos_set_file_size(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ffc1ff88: 94 21 ff e8 stwu r1,-24(r1)
ffc1ff8c: 7c 08 02 a6 mflr r0
ffc1ff90: 7c 89 23 78 mr r9,r4
ffc1ff94: 90 01 00 1c stw r0,28(r1)
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t le_new_length = 0;
uint32_t sec = 0;
uint32_t byte = 0;
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
ffc1ff98: 81 64 00 20 lwz r11,32(r4)
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
ffc1ff9c: 81 43 00 34 lwz r10,52(r3)
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
ffc1ffa0: 2f 8b 00 00 cmpwi cr7,r11,0
ffc1ffa4: 40 9e 00 10 bne- cr7,ffc1ffb4 <msdos_set_file_size+0x2c><== ALWAYS TAKEN
ffc1ffa8: 88 0a 00 0a lbz r0,10(r10) <== NOT EXECUTED
ffc1ffac: 70 08 00 03 andi. r8,r0,3 <== NOT EXECUTED
ffc1ffb0: 40 82 00 70 bne- ffc20020 <msdos_set_file_size+0x98> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
ffc1ffb4: 89 0a 00 05 lbz r8,5(r10)
ffc1ffb8: 38 8b ff fe addi r4,r11,-2
ffc1ffbc: 80 0a 00 30 lwz r0,48(r10)
ffc1ffc0: 7c 84 40 30 slw r4,r4,r8
ffc1ffc4: 7c 84 02 14 add r4,r4,r0
uint32_t le_new_length = 0;
uint32_t sec = 0;
uint32_t byte = 0;
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
ffc1ffc8: 80 09 00 24 lwz r0,36(r9)
ffc1ffcc: 89 6a 00 02 lbz r11,2(r10)
byte = (fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
ffc1ffd0: a0 aa 00 00 lhz r5,0(r10)
uint32_t le_new_length = 0;
uint32_t sec = 0;
uint32_t byte = 0;
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
ffc1ffd4: 7c 0a 5c 30 srw r10,r0,r11
ffc1ffd8: 81 29 00 18 lwz r9,24(r9)
byte = (fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
ffc1ffdc: 38 a5 ff ff addi r5,r5,-1
uint32_t le_new_length = 0;
uint32_t sec = 0;
uint32_t byte = 0;
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
ffc1ffe0: 7c 84 52 14 add r4,r4,r10
byte = (fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
ffc1ffe4: 7c a5 00 38 and r5,r5,r0
ffc1ffe8: 51 20 46 3e rlwimi r0,r9,8,24,31
ffc1ffec: 51 20 c4 2e rlwimi r0,r9,24,16,23
ffc1fff0: 51 20 42 1e rlwimi r0,r9,8,8,15
ffc1fff4: 51 20 c0 0e rlwimi r0,r9,24,0,7
le_new_length = CT_LE_L((fat_fd->fat_file_size));
ffc1fff8: 7c 27 0b 78 mr r7,r1
ffc1fffc: 94 07 00 08 stwu r0,8(r7)
ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_SIZE_OFFSET, 4,
ffc20000: 38 a5 00 1c addi r5,r5,28
ffc20004: 38 c0 00 04 li r6,4
ffc20008: 4b ff 87 7d bl ffc18784 <_fat_block_write>
(char *)(&le_new_length));
if ( ret < 0 )
return -1;
return RC_OK;
}
ffc2000c: 80 01 00 1c lwz r0,28(r1)
ffc20010: 7c 63 fe 70 srawi r3,r3,31
ffc20014: 7c 08 03 a6 mtlr r0
ffc20018: 38 21 00 18 addi r1,r1,24
ffc2001c: 4e 80 00 20 blr
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
return fs_info->vol.rdir_loc;
ffc20020: 80 8a 00 1c lwz r4,28(r10) <== NOT EXECUTED
ffc20024: 4b ff ff a4 b ffc1ffc8 <msdos_set_file_size+0x40> <== NOT EXECUTED
ffc20028 <msdos_set_first_char4file_name>:
msdos_set_first_char4file_name(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
unsigned char fchar
)
{
ffc20028: 94 21 ff c8 stwu r1,-56(r1) <== NOT EXECUTED
ffc2002c: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc20030: 90 01 00 3c stw r0,60(r1) <== NOT EXECUTED
ffc20034: 93 e1 00 34 stw r31,52(r1) <== NOT EXECUTED
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
ffc20038: 83 e3 00 34 lwz r31,52(r3) <== NOT EXECUTED
msdos_set_first_char4file_name(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
unsigned char fchar
)
{
ffc2003c: 93 a1 00 2c stw r29,44(r1) <== NOT EXECUTED
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
fat_pos_t end = dir_pos->sname;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
ffc20040: 80 1f 00 38 lwz r0,56(r31) <== NOT EXECUTED
{
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
fat_pos_t end = dir_pos->sname;
ffc20044: 83 a4 00 00 lwz r29,0(r4) <== NOT EXECUTED
)
{
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
ffc20048: 81 44 00 08 lwz r10,8(r4) <== NOT EXECUTED
fat_pos_t end = dir_pos->sname;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
ffc2004c: 7f 80 e8 00 cmpw cr7,r0,r29 <== NOT EXECUTED
)
{
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
ffc20050: 81 64 00 0c lwz r11,12(r4) <== NOT EXECUTED
msdos_set_first_char4file_name(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
unsigned char fchar
)
{
ffc20054: 93 61 00 24 stw r27,36(r1) <== NOT EXECUTED
ffc20058: 93 c1 00 30 stw r30,48(r1) <== NOT EXECUTED
ffc2005c: 7c 7e 1b 78 mr r30,r3 <== NOT EXECUTED
ffc20060: 93 81 00 28 stw r28,40(r1) <== NOT EXECUTED
ffc20064: 98 a1 00 18 stb r5,24(r1) <== NOT EXECUTED
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
ffc20068: 91 41 00 08 stw r10,8(r1) <== NOT EXECUTED
ffc2006c: 91 61 00 0c stw r11,12(r1) <== NOT EXECUTED
fat_pos_t end = dir_pos->sname;
ffc20070: 83 64 00 04 lwz r27,4(r4) <== NOT EXECUTED
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
ffc20074: 41 9e 01 70 beq- cr7,ffc201e4 <msdos_set_first_char4file_name+0x1bc><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
dir_block_size = fs_info->fat.vol.rdir_size;
else
dir_block_size = fs_info->fat.vol.bpc;
if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
ffc20078: 80 04 00 08 lwz r0,8(r4) <== NOT EXECUTED
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
dir_block_size = fs_info->fat.vol.rdir_size;
else
dir_block_size = fs_info->fat.vol.bpc;
ffc2007c: a3 9f 00 06 lhz r28,6(r31) <== NOT EXECUTED
if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
ffc20080: 2f 80 ff ff cmpwi cr7,r0,-1 <== NOT EXECUTED
ffc20084: 41 9e 01 7c beq- cr7,ffc20200 <msdos_set_first_char4file_name+0x1d8><== NOT EXECUTED
start = dir_pos->sname;
ffc20088: 81 21 00 0c lwz r9,12(r1) <== NOT EXECUTED
msdos_set_first_char4file_name(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
unsigned char fchar
)
{
ffc2008c: 7f eb fb 78 mr r11,r31 <== NOT EXECUTED
dir_block_size = fs_info->fat.vol.rdir_size;
else
dir_block_size = fs_info->fat.vol.bpc;
if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
start = dir_pos->sname;
ffc20090: 88 1f 00 02 lbz r0,2(r31) <== NOT EXECUTED
ffc20094: a0 bf 00 00 lhz r5,0(r31) <== NOT EXECUTED
ffc20098: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
ffc2009c: 48 00 00 68 b ffc20104 <msdos_set_first_char4file_name+0xdc><== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
ffc200a0: 89 4b 00 0a lbz r10,10(r11) <== NOT EXECUTED
ffc200a4: 71 48 00 03 andi. r8,r10,3 <== NOT EXECUTED
ffc200a8: 41 82 00 68 beq- ffc20110 <msdos_set_first_char4file_name+0xe8><== NOT EXECUTED
return fs_info->vol.rdir_loc;
ffc200ac: 80 8b 00 1c lwz r4,28(r11) <== NOT EXECUTED
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(mt_entry, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
ffc200b0: 7d 20 04 30 srw r0,r9,r0 <== NOT EXECUTED
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));;
ffc200b4: 38 a5 ff ff addi r5,r5,-1 <== NOT EXECUTED
ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_NAME_OFFSET, 1,
ffc200b8: 7c a5 48 38 and r5,r5,r9 <== NOT EXECUTED
ffc200bc: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc200c0: 7c 84 02 14 add r4,r4,r0 <== NOT EXECUTED
ffc200c4: 38 c0 00 01 li r6,1 <== NOT EXECUTED
ffc200c8: 38 e1 00 18 addi r7,r1,24 <== NOT EXECUTED
ffc200cc: 4b ff 86 b9 bl ffc18784 <_fat_block_write> <== NOT EXECUTED
&fchar);
if (ret < 0)
ffc200d0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc200d4: 41 9c 00 74 blt- cr7,ffc20148 <msdos_set_first_char4file_name+0x120><== NOT EXECUTED
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
ffc200d8: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
ffc200dc: 81 21 00 0c lwz r9,12(r1) <== NOT EXECUTED
ffc200e0: 7f 84 e8 00 cmpw cr7,r4,r29 <== NOT EXECUTED
ffc200e4: 41 9e 00 8c beq- cr7,ffc20170 <msdos_set_first_char4file_name+0x148><== NOT EXECUTED
break;
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
ffc200e8: 39 29 00 20 addi r9,r9,32 <== NOT EXECUTED
if (start.ofs >= dir_block_size)
ffc200ec: 7f 9c 48 40 cmplw cr7,r28,r9 <== NOT EXECUTED
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
break;
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
ffc200f0: 91 21 00 0c stw r9,12(r1) <== NOT EXECUTED
if (start.ofs >= dir_block_size)
ffc200f4: 40 9d 00 ac ble- cr7,ffc201a0 <msdos_set_first_char4file_name+0x178><== NOT EXECUTED
ffc200f8: 81 7e 00 34 lwz r11,52(r30) <== NOT EXECUTED
ffc200fc: 88 1f 00 02 lbz r0,2(r31) <== NOT EXECUTED
ffc20100: a0 bf 00 00 lhz r5,0(r31) <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
ffc20104: 2f 84 00 00 cmpwi cr7,r4,0 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
ffc20108: 38 84 ff fe addi r4,r4,-2 <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
ffc2010c: 41 be ff 94 beq- cr7,ffc200a0 <msdos_set_first_char4file_name+0x78><== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
ffc20110: 89 4b 00 05 lbz r10,5(r11) <== NOT EXECUTED
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(mt_entry, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
ffc20114: 7d 20 04 30 srw r0,r9,r0 <== NOT EXECUTED
ffc20118: 81 6b 00 30 lwz r11,48(r11) <== NOT EXECUTED
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));;
ffc2011c: 38 a5 ff ff addi r5,r5,-1 <== NOT EXECUTED
ffc20120: 7c 84 50 30 slw r4,r4,r10 <== NOT EXECUTED
ffc20124: 7c 84 5a 14 add r4,r4,r11 <== NOT EXECUTED
ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_NAME_OFFSET, 1,
ffc20128: 7c a5 48 38 and r5,r5,r9 <== NOT EXECUTED
ffc2012c: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc20130: 7c 84 02 14 add r4,r4,r0 <== NOT EXECUTED
ffc20134: 38 c0 00 01 li r6,1 <== NOT EXECUTED
ffc20138: 38 e1 00 18 addi r7,r1,24 <== NOT EXECUTED
ffc2013c: 4b ff 86 49 bl ffc18784 <_fat_block_write> <== NOT EXECUTED
&fchar);
if (ret < 0)
ffc20140: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc20144: 40 9c ff 94 bge+ cr7,ffc200d8 <msdos_set_first_char4file_name+0xb0><== NOT EXECUTED
return -1;
ffc20148: 38 60 ff ff li r3,-1 <== NOT EXECUTED
start.ofs = 0;
}
}
return RC_OK;
}
ffc2014c: 80 01 00 3c lwz r0,60(r1) <== NOT EXECUTED
ffc20150: 83 61 00 24 lwz r27,36(r1) <== NOT EXECUTED
ffc20154: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc20158: 83 81 00 28 lwz r28,40(r1) <== NOT EXECUTED
ffc2015c: 83 a1 00 2c lwz r29,44(r1) <== NOT EXECUTED
ffc20160: 83 c1 00 30 lwz r30,48(r1) <== NOT EXECUTED
ffc20164: 83 e1 00 34 lwz r31,52(r1) <== NOT EXECUTED
ffc20168: 38 21 00 38 addi r1,r1,56 <== NOT EXECUTED
ffc2016c: 4e 80 00 20 blr <== NOT EXECUTED
ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_NAME_OFFSET, 1,
&fchar);
if (ret < 0)
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
ffc20170: 7f 89 d8 00 cmpw cr7,r9,r27 <== NOT EXECUTED
ffc20174: 40 9e ff 74 bne+ cr7,ffc200e8 <msdos_set_first_char4file_name+0xc0><== NOT EXECUTED
start.ofs = 0;
}
}
return RC_OK;
}
ffc20178: 80 01 00 3c lwz r0,60(r1) <== NOT EXECUTED
return rc;
start.ofs = 0;
}
}
return RC_OK;
ffc2017c: 38 60 00 00 li r3,0 <== NOT EXECUTED
}
ffc20180: 83 61 00 24 lwz r27,36(r1) <== NOT EXECUTED
ffc20184: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc20188: 83 81 00 28 lwz r28,40(r1) <== NOT EXECUTED
ffc2018c: 83 a1 00 2c lwz r29,44(r1) <== NOT EXECUTED
ffc20190: 83 c1 00 30 lwz r30,48(r1) <== NOT EXECUTED
ffc20194: 83 e1 00 34 lwz r31,52(r1) <== NOT EXECUTED
ffc20198: 38 21 00 38 addi r1,r1,56 <== NOT EXECUTED
ffc2019c: 4e 80 00 20 blr <== NOT EXECUTED
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
if (start.ofs >= dir_block_size)
{
int rc;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
ffc201a0: 80 1f 00 38 lwz r0,56(r31) <== NOT EXECUTED
ffc201a4: 7f 80 e8 00 cmpw cr7,r0,r29 <== NOT EXECUTED
ffc201a8: 40 9e 00 10 bne- cr7,ffc201b8 <msdos_set_first_char4file_name+0x190><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
ffc201ac: 88 1f 00 0a lbz r0,10(r31) <== NOT EXECUTED
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
if (start.ofs >= dir_block_size)
{
int rc;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
ffc201b0: 70 09 00 03 andi. r9,r0,3 <== NOT EXECUTED
ffc201b4: 40 a2 ff c4 bne- ffc20178 <msdos_set_first_char4file_name+0x150><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
break;
rc = fat_get_fat_cluster(mt_entry, start.cln, &start.cln);
ffc201b8: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc201bc: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
ffc201c0: 48 00 1a 75 bl ffc21c34 <fat_get_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
ffc201c4: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc201c8: 40 a2 ff 84 bne- ffc2014c <msdos_set_first_char4file_name+0x124><== NOT EXECUTED
return rc;
start.ofs = 0;
ffc201cc: 90 61 00 0c stw r3,12(r1) <== NOT EXECUTED
ffc201d0: 39 20 00 00 li r9,0 <== NOT EXECUTED
ffc201d4: 81 7e 00 34 lwz r11,52(r30) <== NOT EXECUTED
ffc201d8: 88 1f 00 02 lbz r0,2(r31) <== NOT EXECUTED
ffc201dc: a0 bf 00 00 lhz r5,0(r31) <== NOT EXECUTED
ffc201e0: 4b ff fe b8 b ffc20098 <msdos_set_first_char4file_name+0x70><== NOT EXECUTED
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
fat_pos_t end = dir_pos->sname;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
ffc201e4: 88 1f 00 0a lbz r0,10(r31) <== NOT EXECUTED
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
fat_pos_t end = dir_pos->sname;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
ffc201e8: 70 08 00 03 andi. r8,r0,3 <== NOT EXECUTED
ffc201ec: 41 a2 fe 8c beq- ffc20078 <msdos_set_first_char4file_name+0x50><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
dir_block_size = fs_info->fat.vol.rdir_size;
else
dir_block_size = fs_info->fat.vol.bpc;
if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
ffc201f0: 80 04 00 08 lwz r0,8(r4) <== NOT EXECUTED
fat_pos_t start = dir_pos->lname;
fat_pos_t end = dir_pos->sname;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
dir_block_size = fs_info->fat.vol.rdir_size;
ffc201f4: 83 9f 00 28 lwz r28,40(r31) <== NOT EXECUTED
else
dir_block_size = fs_info->fat.vol.bpc;
if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
ffc201f8: 2f 80 ff ff cmpwi cr7,r0,-1 <== NOT EXECUTED
ffc201fc: 40 9e fe 8c bne+ cr7,ffc20088 <msdos_set_first_char4file_name+0x60><== NOT EXECUTED
start = dir_pos->sname;
ffc20200: 81 44 00 00 lwz r10,0(r4) <== NOT EXECUTED
ffc20204: 81 64 00 04 lwz r11,4(r4) <== NOT EXECUTED
ffc20208: 91 41 00 08 stw r10,8(r1) <== NOT EXECUTED
ffc2020c: 91 61 00 0c stw r11,12(r1) <== NOT EXECUTED
ffc20210: 4b ff fe 78 b ffc20088 <msdos_set_first_char4file_name+0x60><== NOT EXECUTED
ffc1fe70 <msdos_set_first_cluster_num>:
int
msdos_set_first_cluster_num(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ffc1fe70: 94 21 ff d0 stwu r1,-48(r1)
ffc1fe74: 7c 08 02 a6 mflr r0
ffc1fe78: 90 01 00 34 stw r0,52(r1)
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t new_cln = fat_fd->cln;
uint16_t le_cl_low = 0;
uint16_t le_cl_hi = 0;
ffc1fe7c: 38 00 00 00 li r0,0
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
ffc1fe80: 81 24 00 20 lwz r9,32(r4)
int
msdos_set_first_cluster_num(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ffc1fe84: 93 81 00 20 stw r28,32(r1)
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
ffc1fe88: 2f 89 00 00 cmpwi cr7,r9,0
ffc1fe8c: 93 e1 00 2c stw r31,44(r1)
ffc1fe90: 7c 7f 1b 78 mr r31,r3
ffc1fe94: 93 61 00 1c stw r27,28(r1)
ffc1fe98: 93 a1 00 24 stw r29,36(r1)
ffc1fe9c: 93 c1 00 28 stw r30,40(r1)
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
ffc1fea0: 81 63 00 34 lwz r11,52(r3)
uint32_t new_cln = fat_fd->cln;
ffc1fea4: 83 84 00 1c lwz r28,28(r4)
uint16_t le_cl_low = 0;
uint16_t le_cl_hi = 0;
ffc1fea8: b0 01 00 08 sth r0,8(r1)
ffc1feac: 40 9e 00 10 bne- cr7,ffc1febc <msdos_set_first_cluster_num+0x4c>
ffc1feb0: 88 0b 00 0a lbz r0,10(r11)
ffc1feb4: 70 0a 00 03 andi. r10,r0,3
ffc1feb8: 40 82 00 c8 bne- ffc1ff80 <msdos_set_first_cluster_num+0x110><== ALWAYS TAKEN
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
ffc1febc: 89 4b 00 05 lbz r10,5(r11)
ffc1fec0: 3b a9 ff fe addi r29,r9,-2
ffc1fec4: 80 0b 00 30 lwz r0,48(r11)
ffc1fec8: 7f bd 50 30 slw r29,r29,r10
ffc1fecc: 7f bd 02 14 add r29,r29,r0
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
ffc1fed0: 80 04 00 24 lwz r0,36(r4)
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ffc1fed4: 57 8a 04 3e clrlwi r10,r28,16
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
ffc1fed8: a3 cb 00 00 lhz r30,0(r11)
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ffc1fedc: 55 49 40 2e rlwinm r9,r10,8,0,23
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
ffc1fee0: 89 6b 00 02 lbz r11,2(r11)
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ffc1fee4: 55 4a c2 3e rlwinm r10,r10,24,8,31
ffc1fee8: 7c 27 0b 78 mr r7,r1
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
ffc1feec: 7c 0b 5c 30 srw r11,r0,r11
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ffc1fef0: 7d 2a 53 78 or r10,r9,r10
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
ffc1fef4: 3b de ff ff addi r30,r30,-1
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ffc1fef8: b5 47 00 0a sthu r10,10(r7)
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
ffc1fefc: 7f de 00 38 and r30,r30,r0
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
ffc1ff00: 7f bd 5a 14 add r29,r29,r11
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ret1 = _fat_block_write(mt_entry, sec,
ffc1ff04: 7f a4 eb 78 mr r4,r29
ffc1ff08: 38 be 00 1a addi r5,r30,26
ffc1ff0c: 38 c0 00 02 li r6,2
byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2,
(char *)(&le_cl_low));
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
ffc1ff10: 57 9c 84 3e rlwinm r28,r28,16,16,31
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ret1 = _fat_block_write(mt_entry, sec,
ffc1ff14: 7f e3 fb 78 mr r3,r31
ffc1ff18: 4b ff 88 6d bl ffc18784 <_fat_block_write>
byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2,
(char *)(&le_cl_low));
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
ffc1ff1c: 57 80 40 2e rlwinm r0,r28,8,0,23
ffc1ff20: 57 9c c2 3e rlwinm r28,r28,24,8,31
ffc1ff24: 7c 1c e3 78 or r28,r0,r28
ffc1ff28: 7c 27 0b 78 mr r7,r1
ffc1ff2c: b7 87 00 08 sthu r28,8(r7)
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ret1 = _fat_block_write(mt_entry, sec,
ffc1ff30: 7c 7b 1b 78 mr r27,r3
byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2,
(char *)(&le_cl_low));
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
ret2 = _fat_block_write(mt_entry, sec,
ffc1ff34: 7f a4 eb 78 mr r4,r29
ffc1ff38: 7f e3 fb 78 mr r3,r31
ffc1ff3c: 38 be 00 14 addi r5,r30,20
ffc1ff40: 38 c0 00 02 li r6,2
ffc1ff44: 4b ff 88 41 bl ffc18784 <_fat_block_write>
byte + MSDOS_FIRST_CLUSTER_HI_OFFSET, 2,
(char *)(&le_cl_hi));
if ( (ret1 < 0) || (ret2 < 0) )
ffc1ff48: 2f 9b 00 00 cmpwi cr7,r27,0
return -1;
ffc1ff4c: 38 00 ff ff li r0,-1
(char *)(&le_cl_low));
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
ret2 = _fat_block_write(mt_entry, sec,
byte + MSDOS_FIRST_CLUSTER_HI_OFFSET, 2,
(char *)(&le_cl_hi));
if ( (ret1 < 0) || (ret2 < 0) )
ffc1ff50: 41 9c 00 08 blt- cr7,ffc1ff58 <msdos_set_first_cluster_num+0xe8><== NEVER TAKEN
return -1;
ffc1ff54: 7c 60 fe 70 srawi r0,r3,31
return RC_OK;
}
ffc1ff58: 7c 03 03 78 mr r3,r0
ffc1ff5c: 80 01 00 34 lwz r0,52(r1)
ffc1ff60: 83 61 00 1c lwz r27,28(r1)
ffc1ff64: 7c 08 03 a6 mtlr r0
ffc1ff68: 83 81 00 20 lwz r28,32(r1)
ffc1ff6c: 83 a1 00 24 lwz r29,36(r1)
ffc1ff70: 83 c1 00 28 lwz r30,40(r1)
ffc1ff74: 83 e1 00 2c lwz r31,44(r1)
ffc1ff78: 38 21 00 30 addi r1,r1,48
ffc1ff7c: 4e 80 00 20 blr
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
return fs_info->vol.rdir_loc;
ffc1ff80: 83 ab 00 1c lwz r29,28(r11)
ffc1ff84: 4b ff ff 4c b ffc1fed0 <msdos_set_first_cluster_num+0x60>
ffc1f868 <msdos_shut_down>:
* RC_OK on success, or -1 if error occured (errno set apropriately).
*
*/
int
msdos_shut_down(rtems_filesystem_mount_table_entry_t *temp_mt_entry)
{
ffc1f868: 94 21 ff e8 stwu r1,-24(r1) <== NOT EXECUTED
ffc1f86c: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc1f870: 90 01 00 1c stw r0,28(r1) <== NOT EXECUTED
int rc = RC_OK;
msdos_fs_info_t *fs_info = temp_mt_entry->fs_info;
fat_file_fd_t *fat_fd = temp_mt_entry->mt_fs_root.node_access;
/* close fat-file which correspondes to root directory */
if (fat_file_close(temp_mt_entry, fat_fd) != RC_OK)
ffc1f874: 80 83 00 1c lwz r4,28(r3) <== NOT EXECUTED
* RC_OK on success, or -1 if error occured (errno set apropriately).
*
*/
int
msdos_shut_down(rtems_filesystem_mount_table_entry_t *temp_mt_entry)
{
ffc1f878: 93 a1 00 0c stw r29,12(r1) <== NOT EXECUTED
/* close fat-file which correspondes to root directory */
if (fat_file_close(temp_mt_entry, fat_fd) != RC_OK)
{
/* no return - try to free as much as possible */
rc = -1;
ffc1f87c: 3b a0 ff ff li r29,-1 <== NOT EXECUTED
* RC_OK on success, or -1 if error occured (errno set apropriately).
*
*/
int
msdos_shut_down(rtems_filesystem_mount_table_entry_t *temp_mt_entry)
{
ffc1f880: 93 c1 00 10 stw r30,16(r1) <== NOT EXECUTED
ffc1f884: 93 e1 00 14 stw r31,20(r1) <== NOT EXECUTED
ffc1f888: 7c 7f 1b 78 mr r31,r3 <== NOT EXECUTED
int rc = RC_OK;
msdos_fs_info_t *fs_info = temp_mt_entry->fs_info;
ffc1f88c: 83 c3 00 34 lwz r30,52(r3) <== NOT EXECUTED
fat_file_fd_t *fat_fd = temp_mt_entry->mt_fs_root.node_access;
/* close fat-file which correspondes to root directory */
if (fat_file_close(temp_mt_entry, fat_fd) != RC_OK)
ffc1f890: 4b ff 7f f1 bl ffc17880 <fat_file_close> <== NOT EXECUTED
ffc1f894: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1f898: 40 9e 00 08 bne- cr7,ffc1f8a0 <msdos_shut_down+0x38> <== NOT EXECUTED
*
*/
int
msdos_shut_down(rtems_filesystem_mount_table_entry_t *temp_mt_entry)
{
int rc = RC_OK;
ffc1f89c: 3b a0 00 00 li r29,0 <== NOT EXECUTED
{
/* no return - try to free as much as possible */
rc = -1;
}
if (fat_shutdown_drive(temp_mt_entry) != RC_OK)
ffc1f8a0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1f8a4: 4b ff 94 09 bl ffc18cac <fat_shutdown_drive> <== NOT EXECUTED
ffc1f8a8: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1f8ac: 40 9e 00 3c bne- cr7,ffc1f8e8 <msdos_shut_down+0x80> <== NOT EXECUTED
{
/* no return - try to free as much as possible */
rc = -1;
}
rtems_semaphore_delete(fs_info->vol_sema);
ffc1f8b0: 80 7e 00 98 lwz r3,152(r30) <== NOT EXECUTED
ffc1f8b4: 4b fe dd fd bl ffc0d6b0 <rtems_semaphore_delete> <== NOT EXECUTED
free(fs_info->cl_buf);
ffc1f8b8: 80 7e 00 9c lwz r3,156(r30) <== NOT EXECUTED
ffc1f8bc: 4b fe 8c 25 bl ffc084e0 <free> <== NOT EXECUTED
free(temp_mt_entry->fs_info);
ffc1f8c0: 80 7f 00 34 lwz r3,52(r31) <== NOT EXECUTED
ffc1f8c4: 4b fe 8c 1d bl ffc084e0 <free> <== NOT EXECUTED
return rc;
}
ffc1f8c8: 80 01 00 1c lwz r0,28(r1) <== NOT EXECUTED
ffc1f8cc: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc1f8d0: 83 c1 00 10 lwz r30,16(r1) <== NOT EXECUTED
ffc1f8d4: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc1f8d8: 83 a1 00 0c lwz r29,12(r1) <== NOT EXECUTED
ffc1f8dc: 83 e1 00 14 lwz r31,20(r1) <== NOT EXECUTED
ffc1f8e0: 38 21 00 18 addi r1,r1,24 <== NOT EXECUTED
ffc1f8e4: 4e 80 00 20 blr <== NOT EXECUTED
}
if (fat_shutdown_drive(temp_mt_entry) != RC_OK)
{
/* no return - try to free as much as possible */
rc = -1;
ffc1f8e8: 3b a0 ff ff li r29,-1 <== NOT EXECUTED
ffc1f8ec: 4b ff ff c4 b ffc1f8b0 <msdos_shut_down+0x48> <== NOT EXECUTED
ffc05f94 <newlib_delete_hook>:
void newlib_delete_hook(
rtems_tcb *current_task,
rtems_tcb *deleted_task
)
{
ffc05f94: 7d 80 00 26 mfcr r12
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
ffc05f98: 7e 03 20 00 cmpw cr4,r3,r4
void newlib_delete_hook(
rtems_tcb *current_task,
rtems_tcb *deleted_task
)
{
ffc05f9c: 94 21 ff e8 stwu r1,-24(r1)
ffc05fa0: 7c 08 02 a6 mflr r0
ffc05fa4: 93 c1 00 10 stw r30,16(r1)
ffc05fa8: 7c 9e 23 78 mr r30,r4
ffc05fac: 90 01 00 1c stw r0,28(r1)
ffc05fb0: 93 e1 00 14 stw r31,20(r1)
ffc05fb4: 91 81 00 0c stw r12,12(r1)
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
ffc05fb8: 41 92 00 8c beq- cr4,ffc06044 <newlib_delete_hook+0xb0>
ptr = _REENT;
} else {
ptr = deleted_task->libc_reent;
ffc05fbc: 83 e4 01 2c lwz r31,300(r4)
}
if (ptr && ptr != _global_impure_ptr) {
ffc05fc0: 2f 9f 00 00 cmpwi cr7,r31,0
ffc05fc4: 41 9e 00 2c beq- cr7,ffc05ff0 <newlib_delete_hook+0x5c> <== NEVER TAKEN
ffc05fc8: 3d 20 00 00 lis r9,0
ffc05fcc: 80 09 27 88 lwz r0,10120(r9)
ffc05fd0: 7f 9f 00 00 cmpw cr7,r31,r0
ffc05fd4: 41 9e 00 1c beq- cr7,ffc05ff0 <newlib_delete_hook+0x5c>
_reclaim_reent(ptr);
*/
/*
* Just in case there are some buffers lying around.
*/
_fwalk(ptr, newlib_free_buffers);
ffc05fd8: 3c 80 ff c0 lis r4,-64
ffc05fdc: 7f e3 fb 78 mr r3,r31
ffc05fe0: 38 84 5d 2c addi r4,r4,23852
ffc05fe4: 48 00 e8 c9 bl ffc148ac <_fwalk>
#if REENT_MALLOCED
free(ptr);
#else
_Workspace_Free(ptr);
ffc05fe8: 7f e3 fb 78 mr r3,r31
ffc05fec: 48 00 7c 39 bl ffc0dc24 <_Workspace_Free>
#endif
}
deleted_task->libc_reent = NULL;
ffc05ff0: 38 00 00 00 li r0,0
ffc05ff4: 90 1e 01 2c stw r0,300(r30)
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
ffc05ff8: 41 92 00 24 beq- cr4,ffc0601c <newlib_delete_hook+0x88>
_REENT = 0;
}
}
ffc05ffc: 80 01 00 1c lwz r0,28(r1)
ffc06000: 81 81 00 0c lwz r12,12(r1)
ffc06004: 7c 08 03 a6 mtlr r0
ffc06008: 83 c1 00 10 lwz r30,16(r1)
ffc0600c: 83 e1 00 14 lwz r31,20(r1)
ffc06010: 7d 80 81 20 mtcrf 8,r12
ffc06014: 38 21 00 18 addi r1,r1,24
ffc06018: 4e 80 00 20 blr
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
_REENT = 0;
ffc0601c: 3d 20 00 00 lis r9,0
}
}
ffc06020: 81 81 00 0c lwz r12,12(r1)
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
_REENT = 0;
ffc06024: 90 09 27 8c stw r0,10124(r9)
}
}
ffc06028: 7d 80 81 20 mtcrf 8,r12
ffc0602c: 80 01 00 1c lwz r0,28(r1)
ffc06030: 83 c1 00 10 lwz r30,16(r1)
ffc06034: 7c 08 03 a6 mtlr r0
ffc06038: 83 e1 00 14 lwz r31,20(r1)
ffc0603c: 38 21 00 18 addi r1,r1,24
ffc06040: 4e 80 00 20 blr
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
ptr = _REENT;
ffc06044: 3d 20 00 00 lis r9,0
ffc06048: 83 e9 27 8c lwz r31,10124(r9)
ffc0604c: 4b ff ff 74 b ffc05fc0 <newlib_delete_hook+0x2c>
ffc05d2c <newlib_free_buffers>:
*/
int newlib_free_buffers(
FILE *fp
)
{
ffc05d2c: 94 21 ff f0 stwu r1,-16(r1)
ffc05d30: 7c 08 02 a6 mflr r0
ffc05d34: 93 e1 00 0c stw r31,12(r1)
ffc05d38: 7c 7f 1b 78 mr r31,r3
ffc05d3c: 90 01 00 14 stw r0,20(r1)
switch ( fileno(fp) ) {
ffc05d40: 48 00 e5 71 bl ffc142b0 <fileno>
ffc05d44: 2b 83 00 02 cmplwi cr7,r3,2
ffc05d48: 40 9d 00 24 ble- cr7,ffc05d6c <newlib_free_buffers+0x40><== ALWAYS TAKEN
fp->_flags &= ~__SMBF;
fp->_bf._base = fp->_p = (unsigned char *) NULL;
}
break;
default:
fclose(fp);
ffc05d4c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc05d50: 48 00 e1 c9 bl ffc13f18 <fclose> <== NOT EXECUTED
}
return 0;
}
ffc05d54: 80 01 00 14 lwz r0,20(r1)
ffc05d58: 38 60 00 00 li r3,0
ffc05d5c: 83 e1 00 0c lwz r31,12(r1)
ffc05d60: 38 21 00 10 addi r1,r1,16
ffc05d64: 7c 08 03 a6 mtlr r0
ffc05d68: 4e 80 00 20 blr
{
switch ( fileno(fp) ) {
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
ffc05d6c: a0 1f 00 0c lhz r0,12(r31)
ffc05d70: 70 09 00 80 andi. r9,r0,128
ffc05d74: 41 82 ff e0 beq+ ffc05d54 <newlib_free_buffers+0x28> <== ALWAYS TAKEN
free( fp->_bf._base );
ffc05d78: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc05d7c: 4b ff f4 21 bl ffc0519c <free> <== NOT EXECUTED
fp->_flags &= ~__SMBF;
fp->_bf._base = fp->_p = (unsigned char *) NULL;
ffc05d80: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc05d84: 90 1f 00 00 stw r0,0(r31) <== NOT EXECUTED
break;
default:
fclose(fp);
}
return 0;
}
ffc05d88: 38 60 00 00 li r3,0 <== NOT EXECUTED
case 1:
case 2:
if (fp->_flags & __SMBF) {
free( fp->_bf._base );
fp->_flags &= ~__SMBF;
fp->_bf._base = fp->_p = (unsigned char *) NULL;
ffc05d8c: 90 1f 00 10 stw r0,16(r31) <== NOT EXECUTED
break;
default:
fclose(fp);
}
return 0;
}
ffc05d90: 80 01 00 14 lwz r0,20(r1) <== NOT EXECUTED
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
free( fp->_bf._base );
fp->_flags &= ~__SMBF;
ffc05d94: a1 3f 00 0c lhz r9,12(r31) <== NOT EXECUTED
break;
default:
fclose(fp);
}
return 0;
}
ffc05d98: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
free( fp->_bf._base );
fp->_flags &= ~__SMBF;
ffc05d9c: 55 29 06 6e rlwinm r9,r9,0,25,23 <== NOT EXECUTED
ffc05da0: b1 3f 00 0c sth r9,12(r31) <== NOT EXECUTED
break;
default:
fclose(fp);
}
return 0;
}
ffc05da4: 83 e1 00 0c lwz r31,12(r1) <== NOT EXECUTED
ffc05da8: 38 21 00 10 addi r1,r1,16 <== NOT EXECUTED
ffc05dac: 4e 80 00 20 blr <== NOT EXECUTED
ffc060e8 <open>:
int open(
const char *pathname,
int flags,
...
)
{
ffc060e8: 94 21 ff b0 stwu r1,-80(r1)
ffc060ec: 7c 08 02 a6 mflr r0
ffc060f0: 7d 80 00 26 mfcr r12
ffc060f4: 90 01 00 54 stw r0,84(r1)
/*
* Set the Evaluation flags
*/
eval_flags = 0;
status = flags + 1;
ffc060f8: 38 04 00 01 addi r0,r4,1
if ( ( status & _FREAD ) == _FREAD )
ffc060fc: 70 09 00 01 andi. r9,r0,1
int open(
const char *pathname,
int flags,
...
)
{
ffc06100: 93 61 00 3c stw r27,60(r1)
int eval_flags;
/*
* Set the Evaluation flags
*/
eval_flags = 0;
ffc06104: 3b 60 00 00 li r27,0
int open(
const char *pathname,
int flags,
...
)
{
ffc06108: 93 a1 00 44 stw r29,68(r1)
ffc0610c: 7c 7d 1b 78 mr r29,r3
ffc06110: 93 c1 00 48 stw r30,72(r1)
ffc06114: 7c 9e 23 78 mr r30,r4
ffc06118: 93 41 00 38 stw r26,56(r1)
ffc0611c: 93 81 00 40 stw r28,64(r1)
ffc06120: 93 e1 00 4c stw r31,76(r1)
ffc06124: 91 81 00 34 stw r12,52(r1)
ffc06128: 90 a1 00 28 stw r5,40(r1)
/*
* Set the Evaluation flags
*/
eval_flags = 0;
status = flags + 1;
if ( ( status & _FREAD ) == _FREAD )
ffc0612c: 41 82 00 08 beq- ffc06134 <open+0x4c>
eval_flags |= RTEMS_LIBIO_PERMS_READ;
ffc06130: 3b 60 00 04 li r27,4
if ( ( status & _FWRITE ) == _FWRITE )
ffc06134: 70 09 00 02 andi. r9,r0,2
ffc06138: 41 82 00 08 beq- ffc06140 <open+0x58>
eval_flags |= RTEMS_LIBIO_PERMS_WRITE;
ffc0613c: 63 7b 00 02 ori r27,r27,2
va_start(ap, flags);
ffc06140: 38 01 00 58 addi r0,r1,88
mode = va_arg( ap, int );
ffc06144: 83 81 00 28 lwz r28,40(r1)
if ( ( status & _FREAD ) == _FREAD )
eval_flags |= RTEMS_LIBIO_PERMS_READ;
if ( ( status & _FWRITE ) == _FWRITE )
eval_flags |= RTEMS_LIBIO_PERMS_WRITE;
va_start(ap, flags);
ffc06148: 39 21 00 20 addi r9,r1,32
ffc0614c: 90 01 00 0c stw r0,12(r1)
mode = va_arg( ap, int );
ffc06150: 38 00 00 03 li r0,3
if ( ( status & _FREAD ) == _FREAD )
eval_flags |= RTEMS_LIBIO_PERMS_READ;
if ( ( status & _FWRITE ) == _FWRITE )
eval_flags |= RTEMS_LIBIO_PERMS_WRITE;
va_start(ap, flags);
ffc06154: 91 21 00 10 stw r9,16(r1)
mode = va_arg( ap, int );
ffc06158: 98 01 00 08 stb r0,8(r1)
* 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();
ffc0615c: 48 00 94 c5 bl ffc0f620 <rtems_libio_allocate>
if ( iop == 0 ) {
ffc06160: 2e 03 00 00 cmpwi cr4,r3,0
ffc06164: 7c 7f 1b 78 mr r31,r3
ffc06168: 41 92 00 e0 beq- cr4,ffc06248 <open+0x160>
}
/*
* See if the file exists.
*/
status = rtems_filesystem_evaluate_path(
ffc0616c: 7f a3 eb 78 mr r3,r29
ffc06170: 48 00 f5 49 bl ffc156b8 <strlen>
ffc06174: 7f 65 db 78 mr r5,r27
ffc06178: 7c 64 1b 78 mr r4,r3
ffc0617c: 38 c1 00 14 addi r6,r1,20
ffc06180: 7f a3 eb 78 mr r3,r29
ffc06184: 38 e0 00 01 li r7,1
ffc06188: 4b ff ee 8d bl ffc05014 <rtems_filesystem_evaluate_path>
pathname, strlen( pathname ), eval_flags, &loc, true );
if ( status == -1 ) {
ffc0618c: 2f 83 ff ff cmpwi cr7,r3,-1
ffc06190: 41 9e 01 10 beq- cr7,ffc062a0 <open+0x1b8>
if ( status != 0 ) { /* The file did not exist */
rc = EACCES;
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
ffc06194: 73 c0 0a 00 andi. r0,r30,2560
ffc06198: 2f 80 0a 00 cmpwi cr7,r0,2560
ffc0619c: 41 9e 00 c0 beq- cr7,ffc0625c <open+0x174>
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->flags |= rtems_libio_fcntl_flags( flags );
ffc061a0: 7f c3 f3 78 mr r3,r30
ffc061a4: 83 7f 00 18 lwz r27,24(r31)
ffc061a8: 48 00 93 c9 bl ffc0f570 <rtems_libio_fcntl_flags>
iop->pathinfo = loc;
ffc061ac: 80 01 00 14 lwz r0,20(r1)
ffc061b0: 81 21 00 1c lwz r9,28(r1)
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->flags |= rtems_libio_fcntl_flags( flags );
ffc061b4: 7c 63 db 78 or r3,r3,r27
iop->pathinfo = loc;
ffc061b8: 90 1f 00 1c stw r0,28(r31)
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
ffc061bc: 7f a4 eb 78 mr r4,r29
ffc061c0: 7f c5 f3 78 mr r5,r30
/*
* 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;
ffc061c4: 80 01 00 18 lwz r0,24(r1)
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
ffc061c8: 7f 86 e3 78 mr r6,r28
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->flags |= rtems_libio_fcntl_flags( flags );
ffc061cc: 90 7f 00 18 stw r3,24(r31)
iop->pathinfo = loc;
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
ffc061d0: 7f e3 fb 78 mr r3,r31
/*
* 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;
ffc061d4: 90 1f 00 20 stw r0,32(r31)
ffc061d8: 80 01 00 20 lwz r0,32(r1)
ffc061dc: 91 3f 00 24 stw r9,36(r31)
ffc061e0: 90 1f 00 28 stw r0,40(r31)
ffc061e4: 80 01 00 24 lwz r0,36(r1)
ffc061e8: 90 1f 00 2c stw r0,44(r31)
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
ffc061ec: 80 09 00 00 lwz r0,0(r9)
ffc061f0: 7c 09 03 a6 mtctr r0
ffc061f4: 4e 80 04 21 bctrl
if ( rc ) {
ffc061f8: 2f 83 00 00 cmpwi cr7,r3,0
ffc061fc: 40 9e 00 88 bne- cr7,ffc06284 <open+0x19c>
}
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
ffc06200: 73 c0 04 00 andi. r0,r30,1024
ffc06204: 3f c0 00 00 lis r30,0
ffc06208: 40 82 00 bc bne- ffc062c4 <open+0x1dc>
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
rtems_set_errno_and_return_minus_one( rc );
}
return iop - rtems_libio_iops;
ffc0620c: 80 7e 27 f0 lwz r3,10224(r30)
ffc06210: 7f e3 f8 50 subf r31,r3,r31
ffc06214: 7f e3 36 70 srawi r3,r31,6
}
ffc06218: 80 01 00 54 lwz r0,84(r1)
ffc0621c: 81 81 00 34 lwz r12,52(r1)
ffc06220: 7c 08 03 a6 mtlr r0
ffc06224: 83 41 00 38 lwz r26,56(r1)
ffc06228: 83 61 00 3c lwz r27,60(r1)
ffc0622c: 7d 80 81 20 mtcrf 8,r12
ffc06230: 83 81 00 40 lwz r28,64(r1)
ffc06234: 83 a1 00 44 lwz r29,68(r1)
ffc06238: 83 c1 00 48 lwz r30,72(r1)
ffc0623c: 83 e1 00 4c lwz r31,76(r1)
ffc06240: 38 21 00 50 addi r1,r1,80
ffc06244: 4e 80 00 20 blr
*/
/* allocate a file control block */
iop = rtems_libio_allocate();
if ( iop == 0 ) {
rc = ENFILE;
ffc06248: 3b 40 00 17 li r26,23
if ( rc ) {
if ( iop )
rtems_libio_free( iop );
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
rtems_set_errno_and_return_minus_one( rc );
ffc0624c: 48 00 db 41 bl ffc13d8c <__errno>
ffc06250: 93 43 00 00 stw r26,0(r3)
ffc06254: 38 60 ff ff li r3,-1
ffc06258: 4b ff ff c0 b ffc06218 <open+0x130>
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
/* We were trying to create a file that already exists */
rc = EEXIST;
loc_to_free = &loc;
ffc0625c: 3b 61 00 14 addi r27,r1,20
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;
ffc06260: 3b 40 00 11 li r26,17
*/
done:
va_end(ap);
if ( rc ) {
if ( iop )
ffc06264: 41 92 00 0c beq- cr4,ffc06270 <open+0x188>
rtems_libio_free( iop );
ffc06268: 7f e3 fb 78 mr r3,r31
ffc0626c: 48 00 94 85 bl ffc0f6f0 <rtems_libio_free>
if ( loc_to_free )
ffc06270: 2f 9b 00 00 cmpwi cr7,r27,0
ffc06274: 41 be ff d8 beq- cr7,ffc0624c <open+0x164>
rtems_filesystem_freenode( loc_to_free );
ffc06278: 7f 63 db 78 mr r3,r27
ffc0627c: 4b ff ee f5 bl ffc05170 <rtems_filesystem_freenode>
ffc06280: 4b ff ff cc b ffc0624c <open+0x164>
iop->flags |= rtems_libio_fcntl_flags( flags );
iop->pathinfo = loc;
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
if ( rc ) {
rc = errno;
ffc06284: 48 00 db 09 bl ffc13d8c <__errno>
rc = EEXIST;
loc_to_free = &loc;
goto done;
}
loc_to_free = &loc;
ffc06288: 3b 61 00 14 addi r27,r1,20
iop->flags |= rtems_libio_fcntl_flags( flags );
iop->pathinfo = loc;
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
if ( rc ) {
rc = errno;
ffc0628c: 83 43 00 00 lwz r26,0(r3)
ffc06290: 2e 1a 00 00 cmpwi cr4,r26,0
* Single exit and clean up path.
*/
done:
va_end(ap);
if ( rc ) {
ffc06294: 40 92 00 fc bne- cr4,ffc06390 <open+0x2a8> <== ALWAYS TAKEN
ffc06298: 3f c0 00 00 lis r30,0 <== NOT EXECUTED
ffc0629c: 4b ff ff 70 b ffc0620c <open+0x124> <== NOT EXECUTED
*/
status = rtems_filesystem_evaluate_path(
pathname, strlen( pathname ), eval_flags, &loc, true );
if ( status == -1 ) {
if ( errno != ENOENT ) {
ffc062a0: 48 00 da ed bl ffc13d8c <__errno>
ffc062a4: 80 03 00 00 lwz r0,0(r3)
ffc062a8: 2f 80 00 02 cmpwi cr7,r0,2
ffc062ac: 41 9e 00 68 beq- cr7,ffc06314 <open+0x22c>
rc = errno;
ffc062b0: 48 00 da dd bl ffc13d8c <__errno>
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;
ffc062b4: 3b 60 00 00 li r27,0
status = rtems_filesystem_evaluate_path(
pathname, strlen( pathname ), eval_flags, &loc, true );
if ( status == -1 ) {
if ( errno != ENOENT ) {
rc = errno;
ffc062b8: 83 43 00 00 lwz r26,0(r3)
ffc062bc: 2e 1a 00 00 cmpwi cr4,r26,0
goto done;
ffc062c0: 4b ff ff d4 b ffc06294 <open+0x1ac>
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
rc = ftruncate( iop - rtems_libio_iops, 0 );
ffc062c4: 80 7e 27 f0 lwz r3,10224(r30)
ffc062c8: 38 a0 00 00 li r5,0
ffc062cc: 38 c0 00 00 li r6,0
ffc062d0: 7c 63 f8 50 subf r3,r3,r31
ffc062d4: 7c 63 36 70 srawi r3,r3,6
ffc062d8: 48 00 91 71 bl ffc0f448 <ftruncate>
if ( rc ) {
ffc062dc: 2e 03 00 00 cmpwi cr4,r3,0
ffc062e0: 7c 7a 1b 78 mr r26,r3
ffc062e4: 41 92 ff 28 beq+ cr4,ffc0620c <open+0x124>
if(errno) rc = errno;
ffc062e8: 48 00 da a5 bl ffc13d8c <__errno>
ffc062ec: 80 03 00 00 lwz r0,0(r3)
ffc062f0: 2f 80 00 00 cmpwi cr7,r0,0
ffc062f4: 40 9e 00 5c bne- cr7,ffc06350 <open+0x268> <== ALWAYS TAKEN
close( iop - rtems_libio_iops );
ffc062f8: 80 7e 27 f0 lwz r3,10224(r30)
/* those are released by close(): */
iop = 0;
loc_to_free = NULL;
ffc062fc: 3b 60 00 00 li r27,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 );
ffc06300: 7c 63 f8 50 subf r3,r3,r31
ffc06304: 7c 63 36 70 srawi r3,r3,6
ffc06308: 48 00 90 a1 bl ffc0f3a8 <close>
/* those are released by close(): */
iop = 0;
ffc0630c: 3b e0 00 00 li r31,0
ffc06310: 4b ff ff 84 b ffc06294 <open+0x1ac>
rc = errno;
goto done;
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
ffc06314: 73 c0 02 00 andi. r0,r30,512
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;
ffc06318: 3b 60 00 00 li r27,0
goto done;
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
rc = ENOENT;
ffc0631c: 3b 40 00 02 li r26,2
rc = errno;
goto done;
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
ffc06320: 41 82 ff 44 beq+ ffc06264 <open+0x17c>
rc = ENOENT;
goto done;
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
ffc06324: 7f a3 eb 78 mr r3,r29
ffc06328: 63 84 80 00 ori r4,r28,32768
ffc0632c: 38 a0 00 00 li r5,0
ffc06330: 38 c0 00 00 li r6,0
ffc06334: 4b ff f3 e5 bl ffc05718 <mknod>
if ( rc ) {
ffc06338: 2f 83 00 00 cmpwi cr7,r3,0
ffc0633c: 41 9e 00 24 beq- cr7,ffc06360 <open+0x278> <== ALWAYS TAKEN
rc = errno;
ffc06340: 48 00 da 4d bl ffc13d8c <__errno> <== NOT EXECUTED
ffc06344: 83 43 00 00 lwz r26,0(r3) <== NOT EXECUTED
ffc06348: 2e 1a 00 00 cmpwi cr4,r26,0 <== NOT EXECUTED
goto done;
ffc0634c: 4b ff ff 48 b ffc06294 <open+0x1ac> <== NOT EXECUTED
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
rc = ftruncate( iop - rtems_libio_iops, 0 );
if ( rc ) {
if(errno) rc = errno;
ffc06350: 48 00 da 3d bl ffc13d8c <__errno>
ffc06354: 83 43 00 00 lwz r26,0(r3)
ffc06358: 2e 1a 00 00 cmpwi cr4,r26,0
ffc0635c: 4b ff ff 9c b ffc062f8 <open+0x210>
/*
* 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(
ffc06360: 7f a3 eb 78 mr r3,r29
ffc06364: 48 00 f3 55 bl ffc156b8 <strlen>
ffc06368: 38 a0 00 00 li r5,0
ffc0636c: 7c 64 1b 78 mr r4,r3
ffc06370: 38 c1 00 14 addi r6,r1,20
ffc06374: 7f a3 eb 78 mr r3,r29
ffc06378: 38 e0 00 01 li r7,1
ffc0637c: 4b ff ec 99 bl ffc05014 <rtems_filesystem_evaluate_path>
pathname, strlen( pathname ), 0x0, &loc, true );
if ( status != 0 ) { /* The file did not exist */
rc = EACCES;
ffc06380: 3b 40 00 0d li r26,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 */
ffc06384: 2f 83 00 00 cmpwi cr7,r3,0
ffc06388: 40 be fe dc bne- cr7,ffc06264 <open+0x17c>
ffc0638c: 4b ff fe 14 b ffc061a0 <open+0xb8>
ffc06390: 2e 1f 00 00 cmpwi cr4,r31,0
ffc06394: 4b ff fe d0 b ffc06264 <open+0x17c>
ffc072b0 <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
ffc072b0: 94 21 ff e8 stwu r1,-24(r1)
ffc072b4: 7c 08 02 a6 mflr r0
ffc072b8: 90 01 00 1c stw r0,28(r1)
int i;
if (tty->termios.c_oflag & OPOST) {
ffc072bc: 80 04 00 34 lwz r0,52(r4)
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
ffc072c0: 93 e1 00 14 stw r31,20(r1)
ffc072c4: 7c 9f 23 78 mr r31,r4
int i;
if (tty->termios.c_oflag & OPOST) {
ffc072c8: 70 09 00 01 andi. r9,r0,1
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
ffc072cc: 98 61 00 08 stb r3,8(r1)
int i;
if (tty->termios.c_oflag & OPOST) {
ffc072d0: 41 82 00 70 beq- ffc07340 <oproc+0x90> <== NEVER TAKEN
switch (c) {
ffc072d4: 2f 83 00 09 cmpwi cr7,r3,9
ffc072d8: 41 9e 00 e4 beq- cr7,ffc073bc <oproc+0x10c>
ffc072dc: 2b 83 00 09 cmplwi cr7,r3,9
ffc072e0: 40 9d 00 84 ble- cr7,ffc07364 <oproc+0xb4> <== NEVER TAKEN
ffc072e4: 2f 83 00 0a cmpwi cr7,r3,10
ffc072e8: 41 9e 00 9c beq- cr7,ffc07384 <oproc+0xd4>
ffc072ec: 2f 83 00 0d cmpwi cr7,r3,13
ffc072f0: 41 9e 00 f0 beq- cr7,ffc073e0 <oproc+0x130> <== NEVER TAKEN
if (tty->column > 0)
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
ffc072f4: 70 09 00 02 andi. r9,r0,2
c = toupper(c);
ffc072f8: 3d 20 00 00 lis r9,0
ffc072fc: 80 09 27 84 lwz r0,10116(r9)
if (tty->column > 0)
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
ffc07300: 41 82 00 24 beq- ffc07324 <oproc+0x74> <== ALWAYS TAKEN
c = toupper(c);
ffc07304: 7c 69 1b 78 mr r9,r3 <== NOT EXECUTED
ffc07308: 7c 60 1a 14 add r3,r0,r3 <== NOT EXECUTED
ffc0730c: 89 63 00 01 lbz r11,1(r3) <== NOT EXECUTED
ffc07310: 55 6b 07 be clrlwi r11,r11,30 <== NOT EXECUTED
ffc07314: 2f 8b 00 02 cmpwi cr7,r11,2 <== NOT EXECUTED
ffc07318: 41 9e 01 00 beq- cr7,ffc07418 <oproc+0x168> <== NOT EXECUTED
ffc0731c: 55 23 06 3e clrlwi r3,r9,24 <== NOT EXECUTED
ffc07320: 98 61 00 08 stb r3,8(r1) <== NOT EXECUTED
if (!iscntrl(c))
ffc07324: 7c 60 1a 14 add r3,r0,r3
ffc07328: 88 03 00 01 lbz r0,1(r3)
ffc0732c: 70 09 00 20 andi. r9,r0,32
ffc07330: 40 82 00 10 bne- ffc07340 <oproc+0x90> <== NEVER TAKEN
tty->column++;
ffc07334: 81 3f 00 28 lwz r9,40(r31)
ffc07338: 38 09 00 01 addi r0,r9,1
ffc0733c: 90 1f 00 28 stw r0,40(r31)
break;
}
}
rtems_termios_puts (&c, 1, tty);
ffc07340: 38 61 00 08 addi r3,r1,8
ffc07344: 38 80 00 01 li r4,1
ffc07348: 7f e5 fb 78 mr r5,r31
ffc0734c: 4b ff fd b5 bl ffc07100 <rtems_termios_puts>
}
ffc07350: 80 01 00 1c lwz r0,28(r1)
ffc07354: 83 e1 00 14 lwz r31,20(r1)
ffc07358: 38 21 00 18 addi r1,r1,24
ffc0735c: 7c 08 03 a6 mtlr r0
ffc07360: 4e 80 00 20 blr
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
ffc07364: 2f 83 00 08 cmpwi cr7,r3,8 <== NOT EXECUTED
ffc07368: 40 9e ff 8c bne+ cr7,ffc072f4 <oproc+0x44> <== NOT EXECUTED
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
ffc0736c: 81 24 00 28 lwz r9,40(r4) <== NOT EXECUTED
ffc07370: 2f 89 00 00 cmpwi cr7,r9,0 <== NOT EXECUTED
ffc07374: 40 bd ff cc ble- cr7,ffc07340 <oproc+0x90> <== NOT EXECUTED
tty->column--;
ffc07378: 39 29 ff ff addi r9,r9,-1 <== NOT EXECUTED
ffc0737c: 91 3f 00 28 stw r9,40(r31) <== NOT EXECUTED
ffc07380: 4b ff ff c0 b ffc07340 <oproc+0x90> <== NOT EXECUTED
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
case '\n':
if (tty->termios.c_oflag & ONLRET)
ffc07384: 70 09 00 20 andi. r9,r0,32
ffc07388: 41 82 00 0c beq- ffc07394 <oproc+0xe4> <== ALWAYS TAKEN
tty->column = 0;
ffc0738c: 39 20 00 00 li r9,0 <== NOT EXECUTED
ffc07390: 91 24 00 28 stw r9,40(r4) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLCR) {
ffc07394: 70 09 00 04 andi. r9,r0,4
ffc07398: 41 82 ff a8 beq+ ffc07340 <oproc+0x90> <== NEVER TAKEN
rtems_termios_puts ("\r", 1, tty);
ffc0739c: 3c 60 ff c2 lis r3,-62
ffc073a0: 38 63 0c 24 addi r3,r3,3108
ffc073a4: 38 80 00 01 li r4,1
ffc073a8: 7f e5 fb 78 mr r5,r31
ffc073ac: 4b ff fd 55 bl ffc07100 <rtems_termios_puts>
tty->column = 0;
ffc073b0: 38 00 00 00 li r0,0
ffc073b4: 90 1f 00 28 stw r0,40(r31)
ffc073b8: 4b ff ff 88 b ffc07340 <oproc+0x90>
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
ffc073bc: 54 00 04 e8 rlwinm r0,r0,0,19,20
ffc073c0: 2f 80 18 00 cmpwi cr7,r0,6144
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
ffc073c4: 80 04 00 28 lwz r0,40(r4)
ffc073c8: 54 04 07 7e clrlwi r4,r0,29
ffc073cc: 20 84 00 08 subfic r4,r4,8
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
ffc073d0: 41 9e 00 50 beq- cr7,ffc07420 <oproc+0x170> <== ALWAYS TAKEN
tty->column += i;
rtems_termios_puts ( " ", i, tty);
return;
}
tty->column += i;
ffc073d4: 7c 80 22 14 add r4,r0,r4 <== NOT EXECUTED
ffc073d8: 90 9f 00 28 stw r4,40(r31) <== NOT EXECUTED
break;
ffc073dc: 4b ff ff 64 b ffc07340 <oproc+0x90> <== NOT EXECUTED
tty->column = 0;
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
ffc073e0: 70 09 00 10 andi. r9,r0,16 <== NOT EXECUTED
ffc073e4: 41 82 00 10 beq- ffc073f4 <oproc+0x144> <== NOT EXECUTED
ffc073e8: 81 24 00 28 lwz r9,40(r4) <== NOT EXECUTED
ffc073ec: 2f 89 00 00 cmpwi cr7,r9,0 <== NOT EXECUTED
ffc073f0: 41 be ff 60 beq- cr7,ffc07350 <oproc+0xa0> <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
ffc073f4: 70 09 00 08 andi. r9,r0,8 <== NOT EXECUTED
ffc073f8: 41 a2 ff 84 beq- ffc0737c <oproc+0xcc> <== NOT EXECUTED
c = '\n';
if (tty->termios.c_oflag & ONLRET)
ffc073fc: 70 09 00 20 andi. r9,r0,32 <== NOT EXECUTED
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
return;
if (tty->termios.c_oflag & OCRNL) {
c = '\n';
ffc07400: 38 00 00 0a li r0,10 <== NOT EXECUTED
ffc07404: 98 01 00 08 stb r0,8(r1) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
ffc07408: 41 a2 ff 38 beq- ffc07340 <oproc+0x90> <== NOT EXECUTED
tty->column = 0;
ffc0740c: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc07410: 90 1f 00 28 stw r0,40(r31) <== NOT EXECUTED
ffc07414: 4b ff ff 2c b ffc07340 <oproc+0x90> <== NOT EXECUTED
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
c = toupper(c);
ffc07418: 39 29 ff e0 addi r9,r9,-32 <== NOT EXECUTED
ffc0741c: 4b ff ff 00 b ffc0731c <oproc+0x6c> <== NOT EXECUTED
break;
case '\t':
i = 8 - (tty->column & 7);
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
tty->column += i;
ffc07420: 7c 00 22 14 add r0,r0,r4
ffc07424: 90 1f 00 28 stw r0,40(r31)
rtems_termios_puts ( " ", i, tty);
ffc07428: 3c 60 ff c2 lis r3,-62
ffc0742c: 38 63 0c 28 addi r3,r3,3112
ffc07430: 7f e5 fb 78 mr r5,r31
ffc07434: 4b ff fc cd bl ffc07100 <rtems_termios_puts>
return;
ffc07438: 4b ff ff 18 b ffc07350 <oproc+0xa0>
ffc10658 <pipe_create>:
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
ffc10658: 94 21 ff d8 stwu r1,-40(r1)
ffc1065c: 7c 08 02 a6 mflr r0
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
ffc10660: 38 80 01 ff li r4,511
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
ffc10664: 93 c1 00 20 stw r30,32(r1)
ffc10668: 7c 7e 1b 78 mr r30,r3
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
ffc1066c: 3c 60 ff c2 lis r3,-62
ffc10670: 38 63 32 f4 addi r3,r3,13044
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
ffc10674: 93 e1 00 24 stw r31,36(r1)
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
return -1;
ffc10678: 3b e0 ff ff li r31,-1
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
ffc1067c: 90 01 00 2c stw r0,44(r1)
ffc10680: 93 a1 00 1c stw r29,28(r1)
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
ffc10684: 48 00 1d f5 bl ffc12478 <rtems_mkdir>
ffc10688: 2f 83 00 00 cmpwi cr7,r3,0
ffc1068c: 40 9e 00 cc bne- cr7,ffc10758 <pipe_create+0x100> <== NEVER TAKEN
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
ffc10690: 3d 20 00 00 lis r9,0
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
ffc10694: 3d 40 ff c2 lis r10,-62
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
ffc10698: a0 a9 29 f8 lhz r5,10744(r9)
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
ffc1069c: 39 6a 32 fc addi r11,r10,13052
ffc106a0: 81 0a 32 fc lwz r8,13052(r10)
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
ffc106a4: 3c 80 ff c2 lis r4,-62
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
ffc106a8: 81 4b 00 04 lwz r10,4(r11)
ffc106ac: a1 6b 00 08 lhz r11,8(r11)
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
ffc106b0: 38 05 00 01 addi r0,r5,1
ffc106b4: 38 84 33 08 addi r4,r4,13064
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
ffc106b8: 91 01 00 08 stw r8,8(r1)
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
ffc106bc: 38 61 00 12 addi r3,r1,18
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
ffc106c0: 91 41 00 0c stw r10,12(r1)
ffc106c4: b1 61 00 10 sth r11,16(r1)
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
ffc106c8: b0 09 29 f8 sth r0,10744(r9)
ffc106cc: 4c c6 31 82 crclr 4*cr1+eq
ffc106d0: 48 00 60 a1 bl ffc16770 <sprintf>
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
ffc106d4: 38 61 00 08 addi r3,r1,8
ffc106d8: 38 80 01 80 li r4,384
ffc106dc: 48 00 19 a9 bl ffc12084 <mkfifo>
ffc106e0: 2f 83 00 00 cmpwi cr7,r3,0
ffc106e4: 40 9e 00 d0 bne- cr7,ffc107b4 <pipe_create+0x15c>
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);
ffc106e8: 38 61 00 08 addi r3,r1,8
ffc106ec: 38 80 40 00 li r4,16384
ffc106f0: 4c c6 31 82 crclr 4*cr1+eq
ffc106f4: 4b ff 70 bd bl ffc077b0 <open>
if (filsdes[0] < 0) {
ffc106f8: 2f 83 00 00 cmpwi cr7,r3,0
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);
ffc106fc: 90 7e 00 00 stw r3,0(r30)
if (filsdes[0] < 0) {
ffc10700: 41 9c 00 8c blt- cr7,ffc1078c <pipe_create+0x134>
the file node will be deleted after it is closed by all. */
unlink(fifopath);
}
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
ffc10704: 3d 20 00 00 lis r9,0
ffc10708: 80 09 27 3c lwz r0,10044(r9)
ffc1070c: 39 20 00 00 li r9,0
ffc10710: 7f 83 00 40 cmplw cr7,r3,r0
ffc10714: 41 9c 00 64 blt- cr7,ffc10778 <pipe_create+0x120> <== ALWAYS TAKEN
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
ffc10718: 80 09 00 18 lwz r0,24(r9)
filsdes[1] = open(fifopath, O_WRONLY);
ffc1071c: 38 61 00 08 addi r3,r1,8
ffc10720: 38 80 00 01 li r4,1
unlink(fifopath);
}
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
ffc10724: 54 00 00 3c rlwinm r0,r0,0,0,30
ffc10728: 90 09 00 18 stw r0,24(r9)
int pipe_create(
int filsdes[2]
)
{
rtems_libio_t *iop;
int err = 0;
ffc1072c: 3b a0 00 00 li r29,0
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
filsdes[1] = open(fifopath, O_WRONLY);
ffc10730: 4c c6 31 82 crclr 4*cr1+eq
ffc10734: 4b ff 70 7d bl ffc077b0 <open>
if (filsdes[1] < 0) {
ffc10738: 2f 83 00 00 cmpwi cr7,r3,0
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
filsdes[1] = open(fifopath, O_WRONLY);
ffc1073c: 90 7e 00 04 stw r3,4(r30)
if (filsdes[1] < 0) {
ffc10740: 41 9c 00 60 blt- cr7,ffc107a0 <pipe_create+0x148>
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
ffc10744: 38 61 00 08 addi r3,r1,8
ffc10748: 4b ff 97 8d bl ffc09ed4 <unlink>
}
if(err != 0)
ffc1074c: 2f 9d 00 00 cmpwi cr7,r29,0
rtems_set_errno_and_return_minus_one(err);
return 0;
ffc10750: 3b e0 00 00 li r31,0
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
}
if(err != 0)
ffc10754: 40 9e 00 68 bne- cr7,ffc107bc <pipe_create+0x164>
rtems_set_errno_and_return_minus_one(err);
return 0;
}
ffc10758: 80 01 00 2c lwz r0,44(r1)
ffc1075c: 7f e3 fb 78 mr r3,r31
ffc10760: 83 a1 00 1c lwz r29,28(r1)
ffc10764: 7c 08 03 a6 mtlr r0
ffc10768: 83 c1 00 20 lwz r30,32(r1)
ffc1076c: 83 e1 00 24 lwz r31,36(r1)
ffc10770: 38 21 00 28 addi r1,r1,40
ffc10774: 4e 80 00 20 blr
the file node will be deleted after it is closed by all. */
unlink(fifopath);
}
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
ffc10778: 3d 20 00 00 lis r9,0
ffc1077c: 81 29 27 ec lwz r9,10220(r9)
ffc10780: 54 63 30 32 rlwinm r3,r3,6,0,25
ffc10784: 7d 29 1a 14 add r9,r9,r3
ffc10788: 4b ff ff 90 b ffc10718 <pipe_create+0xc0>
}
/* Non-blocking open to avoid waiting for writers */
filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK);
if (filsdes[0] < 0) {
err = errno;
ffc1078c: 48 00 51 11 bl ffc1589c <__errno>
ffc10790: 83 a3 00 00 lwz r29,0(r3)
/* 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);
ffc10794: 38 61 00 08 addi r3,r1,8
ffc10798: 4b ff 97 3d bl ffc09ed4 <unlink>
ffc1079c: 4b ff ff b0 b ffc1074c <pipe_create+0xf4>
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
filsdes[1] = open(fifopath, O_WRONLY);
if (filsdes[1] < 0) {
err = errno;
ffc107a0: 48 00 50 fd bl ffc1589c <__errno>
ffc107a4: 83 a3 00 00 lwz r29,0(r3)
close(filsdes[0]);
ffc107a8: 80 7e 00 00 lwz r3,0(r30)
ffc107ac: 4b ff 5a c5 bl ffc06270 <close>
ffc107b0: 4b ff ff 94 b ffc10744 <pipe_create+0xec>
memcpy(fifopath, "/tmp/.fifo", 10);
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
if (errno != EEXIST){
ffc107b4: 48 00 50 e9 bl ffc1589c <__errno>
ffc107b8: 4b ff ff a0 b ffc10758 <pipe_create+0x100>
close(filsdes[0]);
}
unlink(fifopath);
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
ffc107bc: 48 00 50 e1 bl ffc1589c <__errno>
ffc107c0: 3b e0 ff ff li r31,-1
ffc107c4: 93 a3 00 00 stw r29,0(r3)
ffc107c8: 4b ff ff 90 b ffc10758 <pipe_create+0x100>
ffc12124 <pipe_ioctl>:
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
ffc12124: 94 21 ff f0 stwu r1,-16(r1)
ffc12128: 7c 08 02 a6 mflr r0
ffc1212c: 90 01 00 14 stw r0,20(r1)
if (cmd == FIONREAD) {
ffc12130: 3c 00 40 04 lis r0,16388
ffc12134: 60 00 66 7f ori r0,r0,26239
ffc12138: 7f 84 00 00 cmpw cr7,r4,r0
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
ffc1213c: 93 c1 00 08 stw r30,8(r1)
ffc12140: 7c be 2b 78 mr r30,r5
ffc12144: 93 e1 00 0c stw r31,12(r1)
ffc12148: 7c 7f 1b 78 mr r31,r3
*(unsigned int *)buffer = pipe->Length;
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
ffc1214c: 38 60 ff ea li r3,-22
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
ffc12150: 40 9e 00 40 bne- cr7,ffc12190 <pipe_ioctl+0x6c>
if (buffer == NULL)
ffc12154: 2f 85 00 00 cmpwi cr7,r5,0
return -EFAULT;
ffc12158: 38 60 ff f2 li r3,-14
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
if (buffer == NULL)
ffc1215c: 41 9e 00 34 beq- cr7,ffc12190 <pipe_ioctl+0x6c>
return -EFAULT;
if (! PIPE_LOCK(pipe))
ffc12160: 80 7f 00 28 lwz r3,40(r31)
ffc12164: 38 80 00 00 li r4,0
ffc12168: 38 a0 00 00 li r5,0
ffc1216c: 4b ff 97 c5 bl ffc0b930 <rtems_semaphore_obtain>
ffc12170: 2f 83 00 00 cmpwi cr7,r3,0
return -EINTR;
ffc12174: 38 60 ff fc li r3,-4
{
if (cmd == FIONREAD) {
if (buffer == NULL)
return -EFAULT;
if (! PIPE_LOCK(pipe))
ffc12178: 40 9e 00 18 bne- cr7,ffc12190 <pipe_ioctl+0x6c> <== NEVER TAKEN
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
ffc1217c: 80 1f 00 0c lwz r0,12(r31)
PIPE_UNLOCK(pipe);
ffc12180: 80 7f 00 28 lwz r3,40(r31)
if (! PIPE_LOCK(pipe))
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
ffc12184: 90 1e 00 00 stw r0,0(r30)
PIPE_UNLOCK(pipe);
ffc12188: 4b ff 99 35 bl ffc0babc <rtems_semaphore_release>
return 0;
ffc1218c: 38 60 00 00 li r3,0
}
return -EINVAL;
}
ffc12190: 80 01 00 14 lwz r0,20(r1)
ffc12194: 83 c1 00 08 lwz r30,8(r1)
ffc12198: 7c 08 03 a6 mtlr r0
ffc1219c: 83 e1 00 0c lwz r31,12(r1)
ffc121a0: 38 21 00 10 addi r1,r1,16
ffc121a4: 4e 80 00 20 blr
ffc11c90 <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
ffc11c90: 94 21 ff c8 stwu r1,-56(r1)
ffc11c94: 7c 08 02 a6 mflr r0
ffc11c98: 90 01 00 3c stw r0,60(r1)
ffc11c9c: 93 e1 00 34 stw r31,52(r1)
ffc11ca0: 7c 7f 1b 78 mr r31,r3
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
ffc11ca4: 80 63 00 28 lwz r3,40(r3)
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
ffc11ca8: 93 a1 00 2c stw r29,44(r1)
ffc11cac: 7c 9d 23 78 mr r29,r4
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
ffc11cb0: 38 80 00 00 li r4,0
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
ffc11cb4: 93 c1 00 30 stw r30,48(r1)
ffc11cb8: 7c be 2b 78 mr r30,r5
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
ffc11cbc: 38 a0 00 00 li r5,0
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
ffc11cc0: 93 41 00 20 stw r26,32(r1)
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
ffc11cc4: 3b 40 ff fc li r26,-4
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
ffc11cc8: 93 61 00 24 stw r27,36(r1)
ffc11ccc: 7c db 33 78 mr r27,r6
ffc11cd0: 93 01 00 18 stw r24,24(r1)
ffc11cd4: 93 21 00 1c stw r25,28(r1)
ffc11cd8: 93 81 00 28 stw r28,40(r1)
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
ffc11cdc: 4b ff 9c 55 bl ffc0b930 <rtems_semaphore_obtain>
ffc11ce0: 2f 83 00 00 cmpwi cr7,r3,0
ffc11ce4: 40 9e 00 a8 bne- cr7,ffc11d8c <pipe_read+0xfc> <== NEVER TAKEN
return -EINTR;
while (read < count) {
ffc11ce8: 2f 9e 00 00 cmpwi cr7,r30,0
ffc11cec: 3b 20 00 00 li r25,0
ffc11cf0: 3b 40 00 00 li r26,0
ffc11cf4: 41 9e 01 68 beq- cr7,ffc11e5c <pipe_read+0x1cc> <== NEVER TAKEN
while (PIPE_EMPTY(pipe)) {
ffc11cf8: 83 9f 00 0c lwz r28,12(r31)
ffc11cfc: 2f 9c 00 00 cmpwi cr7,r28,0
ffc11d00: 40 9e 00 c0 bne- cr7,ffc11dc0 <pipe_read+0x130>
/* Not an error */
if (pipe->Writers == 0)
ffc11d04: 80 1f 00 14 lwz r0,20(r31)
ffc11d08: 2f 80 00 00 cmpwi cr7,r0,0
ffc11d0c: 41 9e 01 50 beq- cr7,ffc11e5c <pipe_read+0x1cc>
goto out_locked;
if (LIBIO_NODELAY(iop)) {
ffc11d10: 80 1b 00 18 lwz r0,24(r27)
ffc11d14: 70 09 00 01 andi. r9,r0,1
ffc11d18: 40 82 01 4c bne- ffc11e64 <pipe_read+0x1d4>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
ffc11d1c: 81 3f 00 18 lwz r9,24(r31)
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ret = -EINTR;
ffc11d20: 3b 80 ff fc li r28,-4
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
PIPE_UNLOCK(pipe);
ffc11d24: 80 7f 00 28 lwz r3,40(r31)
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
ffc11d28: 38 09 00 01 addi r0,r9,1
ffc11d2c: 90 1f 00 18 stw r0,24(r31)
PIPE_UNLOCK(pipe);
ffc11d30: 4b ff 9d 8d bl ffc0babc <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
ffc11d34: 80 7f 00 2c lwz r3,44(r31)
ffc11d38: 38 80 00 00 li r4,0
ffc11d3c: 48 00 1e 81 bl ffc13bbc <rtems_barrier_wait>
ffc11d40: 2f 83 00 00 cmpwi cr7,r3,0
ffc11d44: 40 9e 00 08 bne- cr7,ffc11d4c <pipe_read+0xbc> <== NEVER TAKEN
ffc11d48: 3b 80 00 00 li r28,0
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
ffc11d4c: 80 7f 00 28 lwz r3,40(r31)
ffc11d50: 38 80 00 00 li r4,0
ffc11d54: 38 a0 00 00 li r5,0
ffc11d58: 4b ff 9b d9 bl ffc0b930 <rtems_semaphore_obtain>
ffc11d5c: 2f 83 00 00 cmpwi cr7,r3,0
ffc11d60: 40 9e 01 0c bne- cr7,ffc11e6c <pipe_read+0x1dc> <== NEVER TAKEN
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
if (ret != 0)
ffc11d64: 2f 9c 00 00 cmpwi cr7,r28,0
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
ffc11d68: 81 3f 00 18 lwz r9,24(r31)
ffc11d6c: 38 09 ff ff addi r0,r9,-1
ffc11d70: 90 1f 00 18 stw r0,24(r31)
if (ret != 0)
ffc11d74: 41 9e ff 84 beq+ cr7,ffc11cf8 <pipe_read+0x68> <== ALWAYS TAKEN
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
ffc11d78: 80 7f 00 28 lwz r3,40(r31)
ffc11d7c: 4b ff 9d 41 bl ffc0babc <rtems_semaphore_release>
out_nolock:
if (read > 0)
ffc11d80: 2f 9a 00 00 cmpwi cr7,r26,0
ffc11d84: 41 bd 00 08 bgt+ cr7,ffc11d8c <pipe_read+0xfc>
return read;
return ret;
ffc11d88: 7f 9a e3 78 mr r26,r28
}
ffc11d8c: 80 01 00 3c lwz r0,60(r1)
ffc11d90: 7f 43 d3 78 mr r3,r26
ffc11d94: 83 01 00 18 lwz r24,24(r1)
ffc11d98: 7c 08 03 a6 mtlr r0
ffc11d9c: 83 21 00 1c lwz r25,28(r1)
ffc11da0: 83 41 00 20 lwz r26,32(r1)
ffc11da4: 83 61 00 24 lwz r27,36(r1)
ffc11da8: 83 81 00 28 lwz r28,40(r1)
ffc11dac: 83 a1 00 2c lwz r29,44(r1)
ffc11db0: 83 c1 00 30 lwz r30,48(r1)
ffc11db4: 83 e1 00 34 lwz r31,52(r1)
ffc11db8: 38 21 00 38 addi r1,r1,56
ffc11dbc: 4e 80 00 20 blr
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
ffc11dc0: 7c 19 f0 50 subf r0,r25,r30
ffc11dc4: 7f 9c 00 40 cmplw cr7,r28,r0
ffc11dc8: 40 9d 00 08 ble- cr7,ffc11dd0 <pipe_read+0x140>
ffc11dcc: 7c 1c 03 78 mr r28,r0
chunk1 = pipe->Size - pipe->Start;
ffc11dd0: 80 1f 00 08 lwz r0,8(r31)
ffc11dd4: 83 1f 00 04 lwz r24,4(r31)
if (chunk > chunk1) {
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
ffc11dd8: 80 9f 00 00 lwz r4,0(r31)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
chunk1 = pipe->Size - pipe->Start;
ffc11ddc: 7f 00 c0 50 subf r24,r0,r24
if (chunk > chunk1) {
ffc11de0: 7f 9c c0 00 cmpw cr7,r28,r24
ffc11de4: 40 9d 00 90 ble- cr7,ffc11e74 <pipe_read+0x1e4>
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
ffc11de8: 7f 05 c3 78 mr r5,r24
ffc11dec: 7c 84 02 14 add r4,r4,r0
ffc11df0: 7c 7d ca 14 add r3,r29,r25
ffc11df4: 48 00 58 e9 bl ffc176dc <memcpy>
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
ffc11df8: 7c 79 c2 14 add r3,r25,r24
ffc11dfc: 80 9f 00 00 lwz r4,0(r31)
ffc11e00: 7c 7d 1a 14 add r3,r29,r3
ffc11e04: 7c b8 e0 50 subf r5,r24,r28
ffc11e08: 48 00 58 d5 bl ffc176dc <memcpy>
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
ffc11e0c: 81 3f 00 08 lwz r9,8(r31)
pipe->Start %= pipe->Size;
ffc11e10: 81 7f 00 04 lwz r11,4(r31)
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
ffc11e14: 7d 3c 4a 14 add r9,r28,r9
pipe->Start %= pipe->Size;
pipe->Length -= chunk;
ffc11e18: 80 1f 00 0c lwz r0,12(r31)
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
ffc11e1c: 7d 49 5b 96 divwu r10,r9,r11
pipe->Length -= chunk;
ffc11e20: 7c 1c 00 50 subf r0,r28,r0
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
ffc11e24: 2f 80 00 00 cmpwi cr7,r0,0
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
pipe->Length -= chunk;
ffc11e28: 90 1f 00 0c stw r0,12(r31)
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
ffc11e2c: 7d 6a 59 d6 mullw r11,r10,r11
ffc11e30: 7d 2b 48 50 subf r9,r11,r9
ffc11e34: 91 3f 00 08 stw r9,8(r31)
pipe->Length -= chunk;
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
ffc11e38: 40 9e 00 08 bne- cr7,ffc11e40 <pipe_read+0x1b0>
pipe->Start = 0;
ffc11e3c: 90 1f 00 08 stw r0,8(r31)
if (pipe->waitingWriters > 0)
ffc11e40: 80 1f 00 1c lwz r0,28(r31)
ffc11e44: 2f 80 00 00 cmpwi cr7,r0,0
ffc11e48: 40 9e 00 40 bne- cr7,ffc11e88 <pipe_read+0x1f8>
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
ffc11e4c: 7f 5a e2 14 add r26,r26,r28
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
ffc11e50: 7f 9a f0 40 cmplw cr7,r26,r30
ffc11e54: 7f 59 d3 78 mr r25,r26
ffc11e58: 41 9c fe a0 blt+ cr7,ffc11cf8 <pipe_read+0x68> <== NEVER TAKEN
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
ffc11e5c: 3b 80 00 00 li r28,0
ffc11e60: 4b ff ff 18 b ffc11d78 <pipe_read+0xe8>
goto out_locked;
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
ffc11e64: 3b 80 ff f5 li r28,-11
ffc11e68: 4b ff ff 10 b ffc11d78 <pipe_read+0xe8>
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
ffc11e6c: 3b 80 ff fc li r28,-4 <== NOT EXECUTED
ffc11e70: 4b ff ff 10 b ffc11d80 <pipe_read+0xf0> <== NOT EXECUTED
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);
ffc11e74: 7c 7d ca 14 add r3,r29,r25
ffc11e78: 7c 84 02 14 add r4,r4,r0
ffc11e7c: 7f 85 e3 78 mr r5,r28
ffc11e80: 48 00 58 5d bl ffc176dc <memcpy>
ffc11e84: 4b ff ff 88 b ffc11e0c <pipe_read+0x17c>
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
PIPE_WAKEUPWRITERS(pipe);
ffc11e88: 80 7f 00 30 lwz r3,48(r31)
ffc11e8c: 38 81 00 08 addi r4,r1,8
ffc11e90: 48 00 1c 99 bl ffc13b28 <rtems_barrier_release>
ffc11e94: 4b ff ff b8 b ffc11e4c <pipe_read+0x1bc>
ffc1169c <pipe_release>:
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
ffc1169c: 94 21 ff d8 stwu r1,-40(r1)
ffc116a0: 7c 08 02 a6 mflr r0
ffc116a4: 90 01 00 2c stw r0,44(r1)
/* WARN pipe not released! */
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
ffc116a8: 80 04 00 18 lwz r0,24(r4)
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
ffc116ac: 93 a1 00 1c stw r29,28(r1)
ffc116b0: 7c 7d 1b 78 mr r29,r3
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
if (mode & LIBIO_FLAGS_READ)
ffc116b4: 70 09 00 02 andi. r9,r0,2
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
ffc116b8: 93 c1 00 20 stw r30,32(r1)
/* WARN pipe not released! */
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
ffc116bc: 54 1e 07 7c rlwinm r30,r0,0,29,30
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
ffc116c0: 93 e1 00 24 stw r31,36(r1)
ffc116c4: 93 81 00 18 stw r28,24(r1)
pipe_control_t *pipe = *pipep;
ffc116c8: 83 e3 00 00 lwz r31,0(r3)
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
if (mode & LIBIO_FLAGS_READ)
ffc116cc: 41 82 00 10 beq- ffc116dc <pipe_release+0x40>
pipe->Readers --;
ffc116d0: 81 3f 00 10 lwz r9,16(r31)
ffc116d4: 38 09 ff ff addi r0,r9,-1
ffc116d8: 90 1f 00 10 stw r0,16(r31)
if (mode & LIBIO_FLAGS_WRITE)
ffc116dc: 73 c0 00 04 andi. r0,r30,4
ffc116e0: 41 82 00 10 beq- ffc116f0 <pipe_release+0x54>
pipe->Writers --;
ffc116e4: 81 3f 00 14 lwz r9,20(r31)
ffc116e8: 38 09 ff ff addi r0,r9,-1
ffc116ec: 90 1f 00 14 stw r0,20(r31)
PIPE_UNLOCK(pipe);
ffc116f0: 80 7f 00 28 lwz r3,40(r31)
ffc116f4: 4b ff a3 c9 bl ffc0babc <rtems_semaphore_release>
if (pipe->Readers == 0 && pipe->Writers == 0) {
ffc116f8: 80 1f 00 10 lwz r0,16(r31)
ffc116fc: 2f 80 00 00 cmpwi cr7,r0,0
ffc11700: 41 9e 00 50 beq- cr7,ffc11750 <pipe_release+0xb4>
*pipep = NULL;
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
ffc11704: 80 1f 00 14 lwz r0,20(r31)
ffc11708: 2f 80 00 00 cmpwi cr7,r0,0
ffc1170c: 40 9e 00 18 bne- cr7,ffc11724 <pipe_release+0x88> <== NEVER TAKEN
ffc11710: 2f 9e 00 02 cmpwi cr7,r30,2
ffc11714: 41 9e 00 10 beq- cr7,ffc11724 <pipe_release+0x88> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
ffc11718: 80 7f 00 2c lwz r3,44(r31)
ffc1171c: 38 81 00 08 addi r4,r1,8
ffc11720: 48 00 24 09 bl ffc13b28 <rtems_barrier_release>
static void pipe_unlock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_semaphore_release(pipe_semaphore);
ffc11724: 3d 20 00 00 lis r9,0
ffc11728: 80 69 29 f8 lwz r3,10744(r9)
ffc1172c: 4b ff a3 91 bl ffc0babc <rtems_semaphore_release>
iop->flags &= ~LIBIO_FLAGS_OPEN;
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return;
#endif
}
ffc11730: 80 01 00 2c lwz r0,44(r1)
ffc11734: 83 81 00 18 lwz r28,24(r1)
ffc11738: 7c 08 03 a6 mtlr r0
ffc1173c: 83 a1 00 1c lwz r29,28(r1)
ffc11740: 83 c1 00 20 lwz r30,32(r1)
ffc11744: 83 e1 00 24 lwz r31,36(r1)
ffc11748: 38 21 00 28 addi r1,r1,40
ffc1174c: 4e 80 00 20 blr
if (mode & LIBIO_FLAGS_WRITE)
pipe->Writers --;
PIPE_UNLOCK(pipe);
if (pipe->Readers == 0 && pipe->Writers == 0) {
ffc11750: 83 9f 00 14 lwz r28,20(r31)
ffc11754: 2f 9c 00 00 cmpwi cr7,r28,0
ffc11758: 41 9e 00 44 beq- cr7,ffc1179c <pipe_release+0x100>
delfile = TRUE;
#endif
pipe_free(pipe);
*pipep = NULL;
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
ffc1175c: 2f 9e 00 04 cmpwi cr7,r30,4
ffc11760: 41 9e ff c4 beq+ cr7,ffc11724 <pipe_release+0x88> <== NEVER TAKEN
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
ffc11764: 80 7f 00 30 lwz r3,48(r31)
ffc11768: 38 81 00 08 addi r4,r1,8
ffc1176c: 48 00 23 bd bl ffc13b28 <rtems_barrier_release>
static void pipe_unlock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_semaphore_release(pipe_semaphore);
ffc11770: 3d 20 00 00 lis r9,0
ffc11774: 80 69 29 f8 lwz r3,10744(r9)
ffc11778: 4b ff a3 45 bl ffc0babc <rtems_semaphore_release>
iop->flags &= ~LIBIO_FLAGS_OPEN;
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return;
#endif
}
ffc1177c: 80 01 00 2c lwz r0,44(r1)
ffc11780: 83 81 00 18 lwz r28,24(r1)
ffc11784: 7c 08 03 a6 mtlr r0
ffc11788: 83 a1 00 1c lwz r29,28(r1)
ffc1178c: 83 c1 00 20 lwz r30,32(r1)
ffc11790: 83 e1 00 24 lwz r31,36(r1)
ffc11794: 38 21 00 28 addi r1,r1,40
ffc11798: 4e 80 00 20 blr
/* Called with pipe_semaphore held. */
static inline void pipe_free(
pipe_control_t *pipe
)
{
rtems_barrier_delete(pipe->readBarrier);
ffc1179c: 80 7f 00 2c lwz r3,44(r31)
ffc117a0: 48 00 22 bd bl ffc13a5c <rtems_barrier_delete>
rtems_barrier_delete(pipe->writeBarrier);
ffc117a4: 80 7f 00 30 lwz r3,48(r31)
ffc117a8: 48 00 22 b5 bl ffc13a5c <rtems_barrier_delete>
rtems_semaphore_delete(pipe->Semaphore);
ffc117ac: 80 7f 00 28 lwz r3,40(r31)
ffc117b0: 4b ff a0 a5 bl ffc0b854 <rtems_semaphore_delete>
free(pipe->Buffer);
ffc117b4: 80 7f 00 00 lwz r3,0(r31)
ffc117b8: 4b ff 58 c9 bl ffc07080 <free>
free(pipe);
ffc117bc: 7f e3 fb 78 mr r3,r31
ffc117c0: 4b ff 58 c1 bl ffc07080 <free>
static void pipe_unlock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_semaphore_release(pipe_semaphore);
ffc117c4: 3d 20 00 00 lis r9,0
/* To delete an anonymous pipe file when all users closed it */
if (pipe->Anonymous)
delfile = TRUE;
#endif
pipe_free(pipe);
*pipep = NULL;
ffc117c8: 93 9d 00 00 stw r28,0(r29)
static void pipe_unlock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_semaphore_release(pipe_semaphore);
ffc117cc: 80 69 29 f8 lwz r3,10744(r9)
ffc117d0: 4b ff a2 ed bl ffc0babc <rtems_semaphore_release>
iop->flags &= ~LIBIO_FLAGS_OPEN;
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return;
#endif
}
ffc117d4: 80 01 00 2c lwz r0,44(r1)
ffc117d8: 83 81 00 18 lwz r28,24(r1)
ffc117dc: 7c 08 03 a6 mtlr r0
ffc117e0: 83 a1 00 1c lwz r29,28(r1)
ffc117e4: 83 c1 00 20 lwz r30,32(r1)
ffc117e8: 83 e1 00 24 lwz r31,36(r1)
ffc117ec: 38 21 00 28 addi r1,r1,40
ffc117f0: 4e 80 00 20 blr
ffc11e98 <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
ffc11e98: 94 21 ff c8 stwu r1,-56(r1)
ffc11e9c: 7c 08 02 a6 mflr r0
ffc11ea0: 93 c1 00 30 stw r30,48(r1)
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
ffc11ea4: 7c be 2b 79 mr. r30,r5
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
ffc11ea8: 93 41 00 20 stw r26,32(r1)
ffc11eac: 7c da 33 78 mr r26,r6
ffc11eb0: 93 61 00 24 stw r27,36(r1)
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
return 0;
ffc11eb4: 3b 60 00 00 li r27,0
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
ffc11eb8: 93 a1 00 2c stw r29,44(r1)
ffc11ebc: 7c 9d 23 78 mr r29,r4
ffc11ec0: 93 e1 00 34 stw r31,52(r1)
ffc11ec4: 7c 7f 1b 78 mr r31,r3
ffc11ec8: 90 01 00 3c stw r0,60(r1)
ffc11ecc: 93 01 00 18 stw r24,24(r1)
ffc11ed0: 93 21 00 1c stw r25,28(r1)
ffc11ed4: 93 81 00 28 stw r28,40(r1)
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
ffc11ed8: 40 82 00 38 bne- ffc11f10 <pipe_write+0x78> <== ALWAYS TAKEN
#endif
if (written > 0)
return written;
return ret;
}
ffc11edc: 80 01 00 3c lwz r0,60(r1)
ffc11ee0: 7f 63 db 78 mr r3,r27
ffc11ee4: 83 01 00 18 lwz r24,24(r1)
ffc11ee8: 7c 08 03 a6 mtlr r0
ffc11eec: 83 21 00 1c lwz r25,28(r1)
ffc11ef0: 83 41 00 20 lwz r26,32(r1)
ffc11ef4: 83 61 00 24 lwz r27,36(r1)
ffc11ef8: 83 81 00 28 lwz r28,40(r1)
ffc11efc: 83 a1 00 2c lwz r29,44(r1)
ffc11f00: 83 c1 00 30 lwz r30,48(r1)
ffc11f04: 83 e1 00 34 lwz r31,52(r1)
ffc11f08: 38 21 00 38 addi r1,r1,56
ffc11f0c: 4e 80 00 20 blr
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
ffc11f10: 80 63 00 28 lwz r3,40(r3)
ffc11f14: 38 80 00 00 li r4,0
ffc11f18: 38 a0 00 00 li r5,0
ffc11f1c: 4b ff 9a 15 bl ffc0b930 <rtems_semaphore_obtain>
return -EINTR;
ffc11f20: 3b 60 ff fc li r27,-4
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
ffc11f24: 2f 83 00 00 cmpwi cr7,r3,0
ffc11f28: 40 be ff b4 bne- cr7,ffc11edc <pipe_write+0x44> <== NEVER TAKEN
return -EINTR;
if (pipe->Readers == 0) {
ffc11f2c: 80 1f 00 10 lwz r0,16(r31)
ffc11f30: 2f 80 00 00 cmpwi cr7,r0,0
ffc11f34: 41 9e 01 a4 beq- cr7,ffc120d8 <pipe_write+0x240>
ret = -EPIPE;
goto out_locked;
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
ffc11f38: 81 3f 00 04 lwz r9,4(r31)
ffc11f3c: 3b 20 00 01 li r25,1
ffc11f40: 7f 9e 48 40 cmplw cr7,r30,r9
ffc11f44: 40 9d 01 84 ble- cr7,ffc120c8 <pipe_write+0x230> <== ALWAYS TAKEN
ffc11f48: 3b 00 00 00 li r24,0
ffc11f4c: 3b 60 00 00 li r27,0
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
ffc11f50: 80 1f 00 0c lwz r0,12(r31)
ffc11f54: 7f 80 48 50 subf r28,r0,r9
ffc11f58: 7f 9c c8 40 cmplw cr7,r28,r25
ffc11f5c: 40 9c 00 8c bge- cr7,ffc11fe8 <pipe_write+0x150>
if (LIBIO_NODELAY(iop)) {
ffc11f60: 80 1a 00 18 lwz r0,24(r26)
ffc11f64: 70 09 00 01 andi. r9,r0,1
ffc11f68: 40 82 01 8c bne- ffc120f4 <pipe_write+0x25c>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
ffc11f6c: 81 3f 00 1c lwz r9,28(r31)
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
ffc11f70: 3b 80 ff fc li r28,-4
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
ffc11f74: 80 7f 00 28 lwz r3,40(r31)
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
ffc11f78: 38 09 00 01 addi r0,r9,1
ffc11f7c: 90 1f 00 1c stw r0,28(r31)
PIPE_UNLOCK(pipe);
ffc11f80: 4b ff 9b 3d bl ffc0babc <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
ffc11f84: 80 7f 00 30 lwz r3,48(r31)
ffc11f88: 38 80 00 00 li r4,0
ffc11f8c: 48 00 1c 31 bl ffc13bbc <rtems_barrier_wait>
ffc11f90: 2f 83 00 00 cmpwi cr7,r3,0
ffc11f94: 40 9e 00 08 bne- cr7,ffc11f9c <pipe_write+0x104> <== NEVER TAKEN
ffc11f98: 3b 80 00 00 li r28,0
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
ffc11f9c: 80 7f 00 28 lwz r3,40(r31)
ffc11fa0: 38 80 00 00 li r4,0
ffc11fa4: 38 a0 00 00 li r5,0
ffc11fa8: 4b ff 99 89 bl ffc0b930 <rtems_semaphore_obtain>
ffc11fac: 2f 83 00 00 cmpwi cr7,r3,0
ffc11fb0: 40 9e 01 4c bne- cr7,ffc120fc <pipe_write+0x264> <== NEVER TAKEN
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
if (ret != 0)
ffc11fb4: 2f 9c 00 00 cmpwi cr7,r28,0
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
ffc11fb8: 81 3f 00 1c lwz r9,28(r31)
ffc11fbc: 38 09 ff ff addi r0,r9,-1
ffc11fc0: 90 1f 00 1c stw r0,28(r31)
if (ret != 0)
ffc11fc4: 40 9e 00 b4 bne- cr7,ffc12078 <pipe_write+0x1e0> <== NEVER TAKEN
goto out_locked;
if (pipe->Readers == 0) {
ffc11fc8: 80 1f 00 10 lwz r0,16(r31)
ffc11fcc: 2f 80 00 00 cmpwi cr7,r0,0
ffc11fd0: 41 9e 01 00 beq- cr7,ffc120d0 <pipe_write+0x238> <== NEVER TAKEN
ffc11fd4: 81 3f 00 04 lwz r9,4(r31)
/* 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) {
ffc11fd8: 80 1f 00 0c lwz r0,12(r31)
ffc11fdc: 7f 80 48 50 subf r28,r0,r9
ffc11fe0: 7f 9c c8 40 cmplw cr7,r28,r25
ffc11fe4: 41 9c ff 7c blt+ cr7,ffc11f60 <pipe_write+0xc8> <== NEVER TAKEN
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
ffc11fe8: 7d 78 f0 50 subf r11,r24,r30
ffc11fec: 7f 9c 58 40 cmplw cr7,r28,r11
ffc11ff0: 40 9d 00 08 ble- cr7,ffc11ff8 <pipe_write+0x160>
ffc11ff4: 7d 7c 5b 78 mr r28,r11
chunk1 = pipe->Size - PIPE_WSTART(pipe);
ffc11ff8: 81 7f 00 08 lwz r11,8(r31)
if (chunk > chunk1) {
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
ffc11ffc: 7c 9d c2 14 add r4,r29,r24
ffc12000: 80 7f 00 00 lwz r3,0(r31)
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
ffc12004: 7c 00 5a 14 add r0,r0,r11
ffc12008: 7d 60 4b 96 divwu r11,r0,r9
ffc1200c: 7d 6b 49 d6 mullw r11,r11,r9
ffc12010: 7c 0b 00 50 subf r0,r11,r0
ffc12014: 7f 20 48 50 subf r25,r0,r9
if (chunk > chunk1) {
ffc12018: 7f 9c c8 00 cmpw cr7,r28,r25
ffc1201c: 40 9d 00 e8 ble- cr7,ffc12104 <pipe_write+0x26c>
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
ffc12020: 7f 25 cb 78 mr r5,r25
ffc12024: 7c 63 02 14 add r3,r3,r0
ffc12028: 48 00 56 b5 bl ffc176dc <memcpy>
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
ffc1202c: 7c 99 c2 14 add r4,r25,r24
ffc12030: 80 7f 00 00 lwz r3,0(r31)
ffc12034: 7c 9d 22 14 add r4,r29,r4
ffc12038: 7c b9 e0 50 subf r5,r25,r28
ffc1203c: 48 00 56 a1 bl ffc176dc <memcpy>
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
if (pipe->waitingReaders > 0)
ffc12040: 81 3f 00 18 lwz r9,24(r31)
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
ffc12044: 80 1f 00 0c lwz r0,12(r31)
if (pipe->waitingReaders > 0)
ffc12048: 2f 89 00 00 cmpwi cr7,r9,0
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
ffc1204c: 7c 00 e2 14 add r0,r0,r28
ffc12050: 90 1f 00 0c stw r0,12(r31)
if (pipe->waitingReaders > 0)
ffc12054: 40 9e 00 c0 bne- cr7,ffc12114 <pipe_write+0x27c>
PIPE_WAKEUPREADERS(pipe);
written += chunk;
ffc12058: 7f 7b e2 14 add r27,r27,r28
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
ffc1205c: 7f 9e d8 40 cmplw cr7,r30,r27
ffc12060: 7f 78 db 78 mr r24,r27
ffc12064: 40 9d 00 10 ble- cr7,ffc12074 <pipe_write+0x1dc> <== ALWAYS TAKEN
ffc12068: 81 3f 00 04 lwz r9,4(r31) <== NOT EXECUTED
pipe->Length += chunk;
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
written += chunk;
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
ffc1206c: 3b 20 00 01 li r25,1 <== NOT EXECUTED
ffc12070: 4b ff fe e0 b ffc11f50 <pipe_write+0xb8> <== NOT EXECUTED
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
ffc12074: 3b 80 00 00 li r28,0
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
}
out_locked:
PIPE_UNLOCK(pipe);
ffc12078: 80 7f 00 28 lwz r3,40(r31)
ffc1207c: 4b ff 9a 41 bl ffc0babc <rtems_semaphore_release>
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
ffc12080: 2f 9c ff e0 cmpwi cr7,r28,-32
ffc12084: 41 9e 00 60 beq- cr7,ffc120e4 <pipe_write+0x24c>
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
ffc12088: 2f 9b 00 00 cmpwi cr7,r27,0
ffc1208c: 41 9d fe 50 bgt+ cr7,ffc11edc <pipe_write+0x44>
return written;
return ret;
}
ffc12090: 80 01 00 3c lwz r0,60(r1)
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
ffc12094: 7f 9b e3 78 mr r27,r28
return written;
return ret;
}
ffc12098: 7f 63 db 78 mr r3,r27
ffc1209c: 83 01 00 18 lwz r24,24(r1)
ffc120a0: 7c 08 03 a6 mtlr r0
ffc120a4: 83 21 00 1c lwz r25,28(r1)
ffc120a8: 83 41 00 20 lwz r26,32(r1)
ffc120ac: 83 61 00 24 lwz r27,36(r1)
ffc120b0: 83 81 00 28 lwz r28,40(r1)
ffc120b4: 83 a1 00 2c lwz r29,44(r1)
ffc120b8: 83 c1 00 30 lwz r30,48(r1)
ffc120bc: 83 e1 00 34 lwz r31,52(r1)
ffc120c0: 38 21 00 38 addi r1,r1,56
ffc120c4: 4e 80 00 20 blr
ret = -EPIPE;
goto out_locked;
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
ffc120c8: 7f d9 f3 78 mr r25,r30
ffc120cc: 4b ff fe 7c b ffc11f48 <pipe_write+0xb0>
pipe->waitingWriters --;
if (ret != 0)
goto out_locked;
if (pipe->Readers == 0) {
ret = -EPIPE;
ffc120d0: 3b 80 ff e0 li r28,-32 <== NOT EXECUTED
ffc120d4: 4b ff ff a4 b ffc12078 <pipe_write+0x1e0> <== NOT EXECUTED
if (! PIPE_LOCK(pipe))
return -EINTR;
if (pipe->Readers == 0) {
ret = -EPIPE;
ffc120d8: 3b 80 ff e0 li r28,-32
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
int chunk, chunk1, written = 0, ret = 0;
ffc120dc: 3b 60 00 00 li r27,0
ffc120e0: 4b ff ff 98 b ffc12078 <pipe_write+0x1e0>
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
ffc120e4: 48 00 0a b9 bl ffc12b9c <getpid>
ffc120e8: 38 80 00 0d li r4,13
ffc120ec: 48 00 0f 11 bl ffc12ffc <kill>
ffc120f0: 4b ff ff 98 b ffc12088 <pipe_write+0x1f0>
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
ffc120f4: 3b 80 ff f5 li r28,-11
ffc120f8: 4b ff ff 80 b ffc12078 <pipe_write+0x1e0>
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
ffc120fc: 3b 80 ff fc li r28,-4 <== NOT EXECUTED
ffc12100: 4b ff ff 88 b ffc12088 <pipe_write+0x1f0> <== NOT EXECUTED
if (chunk > chunk1) {
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
ffc12104: 7c 63 02 14 add r3,r3,r0
ffc12108: 7f 85 e3 78 mr r5,r28
ffc1210c: 48 00 55 d1 bl ffc176dc <memcpy>
ffc12110: 4b ff ff 30 b ffc12040 <pipe_write+0x1a8>
pipe->Length += chunk;
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
ffc12114: 80 7f 00 2c lwz r3,44(r31)
ffc12118: 38 81 00 08 addi r4,r1,8
ffc1211c: 48 00 1a 0d bl ffc13b28 <rtems_barrier_release>
ffc12120: 4b ff ff 38 b ffc12058 <pipe_write+0x1c0>
ffc09964 <posix_memalign>:
int posix_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
ffc09964: 7c 08 02 a6 mflr r0
ffc09968: 94 21 ff f8 stwu r1,-8(r1)
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
ffc0996c: 3d 60 00 00 lis r11,0
ffc09970: 39 6b 34 68 addi r11,r11,13416
int posix_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
ffc09974: 90 01 00 0c stw r0,12(r1)
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
ffc09978: 38 04 ff ff addi r0,r4,-1
)
{
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
ffc0997c: 81 4b 00 08 lwz r10,8(r11)
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
ffc09980: 7c 08 20 39 and. r8,r0,r4
)
{
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
ffc09984: 38 0a 00 01 addi r0,r10,1
ffc09988: 90 0b 00 08 stw r0,8(r11)
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
return EINVAL;
ffc0998c: 38 00 00 16 li r0,22
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
ffc09990: 41 82 00 18 beq- ffc099a8 <posix_memalign+0x44> <== ALWAYS TAKEN
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
}
ffc09994: 7c 03 03 78 mr r3,r0
ffc09998: 80 01 00 0c lwz r0,12(r1)
ffc0999c: 38 21 00 08 addi r1,r1,8
ffc099a0: 7c 08 03 a6 mtlr r0
ffc099a4: 4e 80 00 20 blr
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
ffc099a8: 2b 84 00 03 cmplwi cr7,r4,3
ffc099ac: 40 9d ff e8 ble+ cr7,ffc09994 <posix_memalign+0x30>
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
ffc099b0: 48 00 03 75 bl ffc09d24 <rtems_memalign>
ffc099b4: 7c 60 1b 78 mr r0,r3
ffc099b8: 4b ff ff dc b ffc09994 <posix_memalign+0x30>
ffc063ac <printk>:
* printk
*
* Kernel printf function requiring minimal infrastructure.
*/
void printk(const char *fmt, ...)
{
ffc063ac: 94 21 ff 88 stwu r1,-120(r1)
ffc063b0: 7c 08 02 a6 mflr r0
ffc063b4: 90 81 00 1c stw r4,28(r1)
ffc063b8: 90 01 00 7c stw r0,124(r1)
ffc063bc: 90 a1 00 20 stw r5,32(r1)
ffc063c0: 90 c1 00 24 stw r6,36(r1)
ffc063c4: 90 e1 00 28 stw r7,40(r1)
ffc063c8: 91 01 00 2c stw r8,44(r1)
ffc063cc: 91 21 00 30 stw r9,48(r1)
ffc063d0: 91 41 00 34 stw r10,52(r1)
ffc063d4: 40 86 00 24 bne- cr1,ffc063f8 <printk+0x4c> <== ALWAYS TAKEN
ffc063d8: d8 21 00 38 stfd f1,56(r1) <== NOT EXECUTED
ffc063dc: d8 41 00 40 stfd f2,64(r1) <== NOT EXECUTED
ffc063e0: d8 61 00 48 stfd f3,72(r1) <== NOT EXECUTED
ffc063e4: d8 81 00 50 stfd f4,80(r1) <== NOT EXECUTED
ffc063e8: d8 a1 00 58 stfd f5,88(r1) <== NOT EXECUTED
ffc063ec: d8 c1 00 60 stfd f6,96(r1) <== NOT EXECUTED
ffc063f0: d8 e1 00 68 stfd f7,104(r1) <== NOT EXECUTED
ffc063f4: d9 01 00 70 stfd f8,112(r1) <== NOT EXECUTED
va_list ap; /* points to each unnamed argument in turn */
va_start(ap, fmt); /* make ap point to 1st unnamed arg */
ffc063f8: 38 00 00 01 li r0,1
ffc063fc: 98 01 00 08 stb r0,8(r1)
ffc06400: 38 00 00 00 li r0,0
vprintk(fmt, ap);
ffc06404: 38 81 00 08 addi r4,r1,8
*/
void printk(const char *fmt, ...)
{
va_list ap; /* points to each unnamed argument in turn */
va_start(ap, fmt); /* make ap point to 1st unnamed arg */
ffc06408: 98 01 00 09 stb r0,9(r1)
ffc0640c: 38 01 00 80 addi r0,r1,128
ffc06410: 90 01 00 0c stw r0,12(r1)
ffc06414: 38 01 00 18 addi r0,r1,24
ffc06418: 90 01 00 10 stw r0,16(r1)
vprintk(fmt, ap);
ffc0641c: 48 00 23 1d bl ffc08738 <vprintk>
va_end(ap); /* clean up when done */
}
ffc06420: 80 01 00 7c lwz r0,124(r1)
ffc06424: 38 21 00 78 addi r1,r1,120
ffc06428: 7c 08 03 a6 mtlr r0
ffc0642c: 4e 80 00 20 blr
ffc07664 <printk_plugin>:
int printk_plugin(
void *ignored __attribute__((unused)),
const char *format,
...
)
{
ffc07664: 94 21 ff 90 stwu r1,-112(r1)
ffc07668: 7c 08 02 a6 mflr r0
ffc0766c: 90 a1 00 18 stw r5,24(r1)
ffc07670: 90 01 00 74 stw r0,116(r1)
ffc07674: 90 c1 00 1c stw r6,28(r1)
ffc07678: 90 e1 00 20 stw r7,32(r1)
ffc0767c: 91 01 00 24 stw r8,36(r1)
ffc07680: 91 21 00 28 stw r9,40(r1)
ffc07684: 91 41 00 2c stw r10,44(r1)
ffc07688: 40 86 00 24 bne- cr1,ffc076ac <printk_plugin+0x48> <== ALWAYS TAKEN
ffc0768c: d8 21 00 30 stfd f1,48(r1) <== NOT EXECUTED
ffc07690: d8 41 00 38 stfd f2,56(r1) <== NOT EXECUTED
ffc07694: d8 61 00 40 stfd f3,64(r1) <== NOT EXECUTED
ffc07698: d8 81 00 48 stfd f4,72(r1) <== NOT EXECUTED
ffc0769c: d8 a1 00 50 stfd f5,80(r1) <== NOT EXECUTED
ffc076a0: d8 c1 00 58 stfd f6,88(r1) <== NOT EXECUTED
ffc076a4: d8 e1 00 60 stfd f7,96(r1) <== NOT EXECUTED
ffc076a8: d9 01 00 68 stfd f8,104(r1) <== NOT EXECUTED
va_list arg_pointer;
va_start (arg_pointer, format);
ffc076ac: 38 00 00 02 li r0,2
ffc076b0: 98 01 00 08 stb r0,8(r1)
ffc076b4: 38 00 00 00 li r0,0
vprintk( format, arg_pointer );
ffc076b8: 7c 83 23 78 mr r3,r4
...
)
{
va_list arg_pointer;
va_start (arg_pointer, format);
ffc076bc: 98 01 00 09 stb r0,9(r1)
ffc076c0: 38 01 00 78 addi r0,r1,120
vprintk( format, arg_pointer );
ffc076c4: 38 81 00 08 addi r4,r1,8
...
)
{
va_list arg_pointer;
va_start (arg_pointer, format);
ffc076c8: 90 01 00 0c stw r0,12(r1)
ffc076cc: 38 01 00 10 addi r0,r1,16
ffc076d0: 90 01 00 10 stw r0,16(r1)
vprintk( format, arg_pointer );
ffc076d4: 48 00 23 21 bl ffc099f4 <vprintk>
va_end(arg_pointer); /* clean up when done */
return 0;
}
ffc076d8: 38 60 00 00 li r3,0
ffc076dc: 80 01 00 74 lwz r0,116(r1)
ffc076e0: 38 21 00 70 addi r1,r1,112
ffc076e4: 7c 08 03 a6 mtlr r0
ffc076e8: 4e 80 00 20 blr
ffc0ea54 <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
ffc0ea54: 7c 69 1b 79 mr. r9,r3
return EINVAL;
ffc0ea58: 38 60 00 16 li r3,22
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
ffc0ea5c: 4d 82 00 20 beqlr
ffc0ea60: 80 09 00 00 lwz r0,0(r9)
ffc0ea64: 2f 80 00 00 cmpwi cr7,r0,0
ffc0ea68: 4d be 00 20 beqlr+ cr7
return EINVAL;
switch ( policy ) {
ffc0ea6c: 2b 84 00 04 cmplwi cr7,r4,4
ffc0ea70: 41 9d 00 20 bgt- cr7,ffc0ea90 <pthread_attr_setschedpolicy+0x3c>
ffc0ea74: 38 00 00 01 li r0,1
ffc0ea78: 7c 00 20 30 slw r0,r0,r4
ffc0ea7c: 70 0b 00 17 andi. r11,r0,23
ffc0ea80: 41 82 00 10 beq- ffc0ea90 <pthread_attr_setschedpolicy+0x3c><== NEVER TAKEN
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
ffc0ea84: 90 89 00 14 stw r4,20(r9)
return 0;
ffc0ea88: 38 60 00 00 li r3,0
ffc0ea8c: 4e 80 00 20 blr
default:
return ENOTSUP;
ffc0ea90: 38 60 00 86 li r3,134
}
}
ffc0ea94: 4e 80 00 20 blr
ffc0923c <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
ffc0923c: 94 21 ff d0 stwu r1,-48(r1)
ffc09240: 7c 08 02 a6 mflr r0
ffc09244: 93 e1 00 2c stw r31,44(r1)
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
ffc09248: 7c 7f 1b 79 mr. r31,r3
return EINVAL;
ffc0924c: 38 60 00 16 li r3,22
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
ffc09250: 90 01 00 34 stw r0,52(r1)
ffc09254: 93 81 00 20 stw r28,32(r1)
ffc09258: 93 a1 00 24 stw r29,36(r1)
ffc0925c: 93 c1 00 28 stw r30,40(r1)
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
ffc09260: 41 82 00 0c beq- ffc0926c <pthread_barrier_init+0x30>
return EINVAL;
if ( count == 0 )
ffc09264: 2f 85 00 00 cmpwi cr7,r5,0
ffc09268: 40 9e 00 24 bne- cr7,ffc0928c <pthread_barrier_init+0x50>
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
_Thread_Enable_dispatch();
return 0;
}
ffc0926c: 80 01 00 34 lwz r0,52(r1)
ffc09270: 83 81 00 20 lwz r28,32(r1)
ffc09274: 7c 08 03 a6 mtlr r0
ffc09278: 83 a1 00 24 lwz r29,36(r1)
ffc0927c: 83 c1 00 28 lwz r30,40(r1)
ffc09280: 83 e1 00 2c lwz r31,44(r1)
ffc09284: 38 21 00 30 addi r1,r1,48
ffc09288: 4e 80 00 20 blr
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
ffc0928c: 2f 84 00 00 cmpwi cr7,r4,0
ffc09290: 41 9e 00 84 beq- cr7,ffc09314 <pthread_barrier_init+0xd8>
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
ffc09294: 80 04 00 00 lwz r0,0(r4)
return EINVAL;
ffc09298: 38 60 00 16 li r3,22
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
ffc0929c: 2f 80 00 00 cmpwi cr7,r0,0
ffc092a0: 41 9e ff cc beq+ cr7,ffc0926c <pthread_barrier_init+0x30>
return EINVAL;
switch ( the_attr->process_shared ) {
ffc092a4: 83 c4 00 04 lwz r30,4(r4)
ffc092a8: 2f 9e 00 00 cmpwi cr7,r30,0
ffc092ac: 40 be ff c0 bne- cr7,ffc0926c <pthread_barrier_init+0x30><== NEVER TAKEN
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc092b0: 3d 20 00 00 lis r9,0
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
ffc092b4: 93 c1 00 10 stw r30,16(r1)
ffc092b8: 81 69 28 34 lwz r11,10292(r9)
the_attributes.maximum_count = count;
ffc092bc: 90 a1 00 14 stw r5,20(r1)
ffc092c0: 38 0b 00 01 addi r0,r11,1
ffc092c4: 90 09 28 34 stw r0,10292(r9)
return _Thread_Dispatch_disable_level;
ffc092c8: 80 09 28 34 lwz r0,10292(r9)
* This function allocates a barrier control block from
* the inactive chain of free barrier control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Allocate( void )
{
return (POSIX_Barrier_Control *)
ffc092cc: 3f 80 00 00 lis r28,0
ffc092d0: 3b 9c 2f ac addi r28,r28,12204
ffc092d4: 7f 83 e3 78 mr r3,r28
ffc092d8: 48 00 2b 11 bl ffc0bde8 <_Objects_Allocate>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
ffc092dc: 7c 7d 1b 79 mr. r29,r3
ffc092e0: 41 82 00 4c beq- ffc0932c <pthread_barrier_init+0xf0>
_Thread_Enable_dispatch();
return EAGAIN;
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
ffc092e4: 38 7d 00 10 addi r3,r29,16
ffc092e8: 38 81 00 10 addi r4,r1,16
ffc092ec: 48 00 1e 89 bl ffc0b174 <_CORE_barrier_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
ffc092f0: 80 1d 00 08 lwz r0,8(r29)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
ffc092f4: 81 7c 00 1c lwz r11,28(r28)
ffc092f8: 54 09 13 ba rlwinm r9,r0,2,14,29
ffc092fc: 7f ab 49 2e stwx r29,r11,r9
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
ffc09300: 93 dd 00 0c stw r30,12(r29)
);
/*
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
ffc09304: 90 1f 00 00 stw r0,0(r31)
_Thread_Enable_dispatch();
ffc09308: 48 00 41 b1 bl ffc0d4b8 <_Thread_Enable_dispatch>
return 0;
ffc0930c: 38 60 00 00 li r3,0
ffc09310: 4b ff ff 5c b ffc0926c <pthread_barrier_init+0x30>
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
ffc09314: 38 61 00 08 addi r3,r1,8
ffc09318: 90 a1 00 18 stw r5,24(r1)
ffc0931c: 4b ff fe 2d bl ffc09148 <pthread_barrierattr_init>
the_attr = &my_attr;
ffc09320: 38 81 00 08 addi r4,r1,8
ffc09324: 80 a1 00 18 lwz r5,24(r1)
ffc09328: 4b ff ff 6c b ffc09294 <pthread_barrier_init+0x58>
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
_Thread_Enable_dispatch();
ffc0932c: 48 00 41 8d bl ffc0d4b8 <_Thread_Enable_dispatch>
return EAGAIN;
ffc09330: 38 60 00 0b li r3,11
ffc09334: 4b ff ff 38 b ffc0926c <pthread_barrier_init+0x30>
ffc08a0c <pthread_cleanup_push>:
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
ffc08a0c: 94 21 ff f0 stwu r1,-16(r1)
ffc08a10: 7c 08 02 a6 mflr r0
ffc08a14: 93 c1 00 08 stw r30,8(r1)
/*
* 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 )
ffc08a18: 7c 7e 1b 79 mr. r30,r3
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
ffc08a1c: 93 e1 00 0c stw r31,12(r1)
ffc08a20: 7c 9f 23 78 mr r31,r4
ffc08a24: 90 01 00 14 stw r0,20(r1)
/*
* 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 )
ffc08a28: 41 82 00 4c beq- ffc08a74 <pthread_cleanup_push+0x68>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc08a2c: 3d 20 00 00 lis r9,0
ffc08a30: 81 69 28 0c lwz r11,10252(r9)
ffc08a34: 38 0b 00 01 addi r0,r11,1
ffc08a38: 90 09 28 0c stw r0,10252(r9)
return _Thread_Dispatch_disable_level;
ffc08a3c: 80 09 28 0c lwz r0,10252(r9)
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
ffc08a40: 38 60 00 10 li r3,16
ffc08a44: 48 00 5b 7d bl ffc0e5c0 <_Workspace_Allocate>
if ( handler ) {
ffc08a48: 7c 69 1b 79 mr. r9,r3
ffc08a4c: 41 82 00 24 beq- ffc08a70 <pthread_cleanup_push+0x64> <== NEVER TAKEN
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
ffc08a50: 3d 60 00 00 lis r11,0
ffc08a54: 81 6b 31 10 lwz r11,12560(r11)
handler_stack = &thread_support->Cancellation_Handlers;
handler->routine = routine;
handler->arg = arg;
_Chain_Append( handler_stack, &handler->Node );
ffc08a58: 7d 24 4b 78 mr r4,r9
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
if ( handler ) {
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
handler_stack = &thread_support->Cancellation_Handlers;
ffc08a5c: 80 6b 01 34 lwz r3,308(r11)
handler->routine = routine;
ffc08a60: 93 c9 00 08 stw r30,8(r9)
handler->arg = arg;
_Chain_Append( handler_stack, &handler->Node );
ffc08a64: 38 63 00 e4 addi r3,r3,228
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
handler_stack = &thread_support->Cancellation_Handlers;
handler->routine = routine;
handler->arg = arg;
ffc08a68: 93 e9 00 0c stw r31,12(r9)
_Chain_Append( handler_stack, &handler->Node );
ffc08a6c: 48 00 20 7d bl ffc0aae8 <_Chain_Append>
}
_Thread_Enable_dispatch();
ffc08a70: 48 00 43 75 bl ffc0cde4 <_Thread_Enable_dispatch>
}
ffc08a74: 80 01 00 14 lwz r0,20(r1)
ffc08a78: 83 c1 00 08 lwz r30,8(r1)
ffc08a7c: 7c 08 03 a6 mtlr r0
ffc08a80: 83 e1 00 0c lwz r31,12(r1)
ffc08a84: 38 21 00 10 addi r1,r1,16
ffc08a88: 4e 80 00 20 blr
ffc09bc4 <pthread_cond_init>:
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
ffc09bc4: 94 21 ff e8 stwu r1,-24(r1)
ffc09bc8: 7c 08 02 a6 mflr r0
ffc09bcc: 93 81 00 08 stw r28,8(r1)
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
ffc09bd0: 7c 9c 23 79 mr. r28,r4
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
ffc09bd4: 93 e1 00 14 stw r31,20(r1)
ffc09bd8: 7c 7f 1b 78 mr r31,r3
ffc09bdc: 90 01 00 1c stw r0,28(r1)
ffc09be0: 93 a1 00 0c stw r29,12(r1)
ffc09be4: 93 c1 00 10 stw r30,16(r1)
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
ffc09be8: 41 82 00 b8 beq- ffc09ca0 <pthread_cond_init+0xdc>
else the_attr = &_POSIX_Condition_variables_Default_attributes;
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
ffc09bec: 80 1c 00 04 lwz r0,4(r28)
return EINVAL;
ffc09bf0: 38 60 00 16 li r3,22
else the_attr = &_POSIX_Condition_variables_Default_attributes;
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
ffc09bf4: 2f 80 00 01 cmpwi cr7,r0,1
ffc09bf8: 41 9e 00 10 beq- cr7,ffc09c08 <pthread_cond_init+0x44> <== NEVER TAKEN
return EINVAL;
if ( !the_attr->is_initialized )
ffc09bfc: 80 1c 00 00 lwz r0,0(r28)
ffc09c00: 2f 80 00 00 cmpwi cr7,r0,0
ffc09c04: 40 9e 00 24 bne- cr7,ffc09c28 <pthread_cond_init+0x64>
*cond = the_cond->Object.id;
_Thread_Enable_dispatch();
return 0;
}
ffc09c08: 80 01 00 1c lwz r0,28(r1)
ffc09c0c: 83 81 00 08 lwz r28,8(r1)
ffc09c10: 7c 08 03 a6 mtlr r0
ffc09c14: 83 a1 00 0c lwz r29,12(r1)
ffc09c18: 83 c1 00 10 lwz r30,16(r1)
ffc09c1c: 83 e1 00 14 lwz r31,20(r1)
ffc09c20: 38 21 00 18 addi r1,r1,24
ffc09c24: 4e 80 00 20 blr
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc09c28: 3d 20 00 00 lis r9,0
ffc09c2c: 81 69 28 40 lwz r11,10304(r9)
ffc09c30: 38 0b 00 01 addi r0,r11,1
ffc09c34: 90 09 28 40 stw r0,10304(r9)
return _Thread_Dispatch_disable_level;
ffc09c38: 80 09 28 40 lwz r0,10304(r9)
*/
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control
*_POSIX_Condition_variables_Allocate( void )
{
return (POSIX_Condition_variables_Control *)
ffc09c3c: 3f a0 00 00 lis r29,0
ffc09c40: 3b bd 30 64 addi r29,r29,12388
ffc09c44: 7f a3 eb 78 mr r3,r29
ffc09c48: 48 00 33 55 bl ffc0cf9c <_Objects_Allocate>
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
ffc09c4c: 7c 7e 1b 79 mr. r30,r3
ffc09c50: 41 82 00 5c beq- ffc09cac <pthread_cond_init+0xe8>
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
ffc09c54: 80 1c 00 04 lwz r0,4(r28)
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
ffc09c58: 3b 80 00 00 li r28,0
ffc09c5c: 93 9e 00 14 stw r28,20(r30)
_Thread_queue_Initialize(
ffc09c60: 3c a0 10 00 lis r5,4096
ffc09c64: 38 7e 00 18 addi r3,r30,24
if ( !the_cond ) {
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
ffc09c68: 90 1e 00 10 stw r0,16(r30)
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
ffc09c6c: 38 80 00 00 li r4,0
ffc09c70: 60 a5 08 00 ori r5,r5,2048
ffc09c74: 38 c0 00 74 li r6,116
ffc09c78: 48 00 53 f5 bl ffc0f06c <_Thread_queue_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
ffc09c7c: 80 1e 00 08 lwz r0,8(r30)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
ffc09c80: 81 7d 00 1c lwz r11,28(r29)
ffc09c84: 54 09 13 ba rlwinm r9,r0,2,14,29
ffc09c88: 7f cb 49 2e stwx r30,r11,r9
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
ffc09c8c: 93 9e 00 0c stw r28,12(r30)
&_POSIX_Condition_variables_Information,
&the_cond->Object,
0
);
*cond = the_cond->Object.id;
ffc09c90: 90 1f 00 00 stw r0,0(r31)
_Thread_Enable_dispatch();
ffc09c94: 48 00 49 d9 bl ffc0e66c <_Thread_Enable_dispatch>
return 0;
ffc09c98: 38 60 00 00 li r3,0
ffc09c9c: 4b ff ff 6c b ffc09c08 <pthread_cond_init+0x44>
{
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
else the_attr = &_POSIX_Condition_variables_Default_attributes;
ffc09ca0: 3f 80 00 00 lis r28,0
ffc09ca4: 3b 9c 27 88 addi r28,r28,10120
ffc09ca8: 4b ff ff 44 b ffc09bec <pthread_cond_init+0x28>
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
_Thread_Enable_dispatch();
ffc09cac: 48 00 49 c1 bl ffc0e66c <_Thread_Enable_dispatch>
return ENOMEM;
ffc09cb0: 38 60 00 0c li r3,12
ffc09cb4: 4b ff ff 54 b ffc09c08 <pthread_cond_init+0x44>
ffc08f04 <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
ffc08f04: 94 21 ff 80 stwu r1,-128(r1)
ffc08f08: 7c 08 02 a6 mflr r0
ffc08f0c: 93 61 00 6c stw r27,108(r1)
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
ffc08f10: 7c bb 2b 79 mr. r27,r5
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
ffc08f14: 93 81 00 70 stw r28,112(r1)
ffc08f18: 7c dc 33 78 mr r28,r6
ffc08f1c: 93 a1 00 74 stw r29,116(r1)
ffc08f20: 7c 7d 1b 78 mr r29,r3
ffc08f24: 93 e1 00 7c stw r31,124(r1)
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
return EFAULT;
ffc08f28: 3b e0 00 0e li r31,14
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
ffc08f2c: 90 01 00 84 stw r0,132(r1)
ffc08f30: 92 81 00 50 stw r20,80(r1)
ffc08f34: 92 a1 00 54 stw r21,84(r1)
ffc08f38: 92 c1 00 58 stw r22,88(r1)
ffc08f3c: 92 e1 00 5c stw r23,92(r1)
ffc08f40: 93 01 00 60 stw r24,96(r1)
ffc08f44: 93 21 00 64 stw r25,100(r1)
ffc08f48: 93 41 00 68 stw r26,104(r1)
ffc08f4c: 93 c1 00 78 stw r30,120(r1)
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
ffc08f50: 41 82 00 20 beq- ffc08f70 <pthread_create+0x6c>
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
ffc08f54: 2f 84 00 00 cmpwi cr7,r4,0
ffc08f58: 7c 9e 23 78 mr r30,r4
ffc08f5c: 41 9e 01 bc beq- cr7,ffc09118 <pthread_create+0x214>
if ( !the_attr->is_initialized )
ffc08f60: 80 1e 00 00 lwz r0,0(r30)
return EINVAL;
ffc08f64: 3b e0 00 16 li r31,22
if ( !start_routine )
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
if ( !the_attr->is_initialized )
ffc08f68: 2f 80 00 00 cmpwi cr7,r0,0
ffc08f6c: 40 9e 00 48 bne- cr7,ffc08fb4 <pthread_create+0xb0>
*/
*thread = the_thread->Object.id;
_RTEMS_Unlock_allocator();
return 0;
}
ffc08f70: 80 01 00 84 lwz r0,132(r1)
ffc08f74: 7f e3 fb 78 mr r3,r31
ffc08f78: 82 81 00 50 lwz r20,80(r1)
ffc08f7c: 7c 08 03 a6 mtlr r0
ffc08f80: 82 a1 00 54 lwz r21,84(r1)
ffc08f84: 82 c1 00 58 lwz r22,88(r1)
ffc08f88: 82 e1 00 5c lwz r23,92(r1)
ffc08f8c: 83 01 00 60 lwz r24,96(r1)
ffc08f90: 83 21 00 64 lwz r25,100(r1)
ffc08f94: 83 41 00 68 lwz r26,104(r1)
ffc08f98: 83 61 00 6c lwz r27,108(r1)
ffc08f9c: 83 81 00 70 lwz r28,112(r1)
ffc08fa0: 83 a1 00 74 lwz r29,116(r1)
ffc08fa4: 83 c1 00 78 lwz r30,120(r1)
ffc08fa8: 83 e1 00 7c lwz r31,124(r1)
ffc08fac: 38 21 00 80 addi r1,r1,128
ffc08fb0: 4e 80 00 20 blr
* 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) )
ffc08fb4: 80 1e 00 04 lwz r0,4(r30)
ffc08fb8: 2f 80 00 00 cmpwi cr7,r0,0
ffc08fbc: 41 9e 00 18 beq- cr7,ffc08fd4 <pthread_create+0xd0>
ffc08fc0: 3d 60 00 00 lis r11,0
ffc08fc4: 81 3e 00 08 lwz r9,8(r30)
ffc08fc8: 80 0b 27 28 lwz r0,10024(r11)
ffc08fcc: 7f 89 00 40 cmplw cr7,r9,r0
ffc08fd0: 41 9c ff a0 blt+ cr7,ffc08f70 <pthread_create+0x6c>
* 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 ) {
ffc08fd4: 80 1e 00 10 lwz r0,16(r30)
ffc08fd8: 2f 80 00 01 cmpwi cr7,r0,1
ffc08fdc: 41 9e 01 48 beq- cr7,ffc09124 <pthread_create+0x220>
ffc08fe0: 2f 80 00 02 cmpwi cr7,r0,2
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
break;
default:
return EINVAL;
ffc08fe4: 3b e0 00 16 li r31,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 ) {
ffc08fe8: 40 9e ff 88 bne+ cr7,ffc08f70 <pthread_create+0x6c>
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
ffc08fec: 80 de 00 18 lwz r6,24(r30)
ffc08ff0: 80 fe 00 1c lwz r7,28(r30)
ffc08ff4: 81 1e 00 20 lwz r8,32(r30)
ffc08ff8: 81 5e 00 24 lwz r10,36(r30)
ffc08ffc: 81 7e 00 28 lwz r11,40(r30)
ffc09000: 81 3e 00 2c lwz r9,44(r30)
ffc09004: 80 1e 00 30 lwz r0,48(r30)
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
ffc09008: 83 5e 00 14 lwz r26,20(r30)
schedparam = the_attr->schedparam;
ffc0900c: 90 c1 00 20 stw r6,32(r1)
ffc09010: 90 e1 00 24 stw r7,36(r1)
ffc09014: 91 01 00 28 stw r8,40(r1)
ffc09018: 91 41 00 2c stw r10,44(r1)
ffc0901c: 91 61 00 30 stw r11,48(r1)
ffc09020: 91 21 00 34 stw r9,52(r1)
ffc09024: 90 01 00 38 stw r0,56(r1)
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
ffc09028: 80 1e 00 0c lwz r0,12(r30)
return ENOTSUP;
ffc0902c: 3b e0 00 86 li r31,134
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
ffc09030: 2f 80 00 00 cmpwi cr7,r0,0
ffc09034: 40 9e ff 3c bne+ cr7,ffc08f70 <pthread_create+0x6c>
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
ffc09038: 80 61 00 20 lwz r3,32(r1)
return EINVAL;
ffc0903c: 3b e0 00 16 li r31,22
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
ffc09040: 48 00 83 19 bl ffc11358 <_POSIX_Priority_Is_valid>
ffc09044: 2f 83 00 00 cmpwi cr7,r3,0
ffc09048: 41 9e ff 28 beq+ cr7,ffc08f70 <pthread_create+0x6c> <== NEVER TAKEN
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
ffc0904c: 7c 24 0b 78 mr r4,r1
ffc09050: 86 c4 00 20 lwzu r22,32(r4)
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
ffc09054: 3d 20 00 00 lis r9,0
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
ffc09058: 7f 43 d3 78 mr r3,r26
ffc0905c: 8a a9 27 24 lbz r21,10020(r9)
ffc09060: 38 a1 00 1c addi r5,r1,28
ffc09064: 38 c1 00 18 addi r6,r1,24
ffc09068: 48 00 83 15 bl ffc1137c <_POSIX_Thread_Translate_sched_param>
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( rc )
ffc0906c: 7c 7f 1b 79 mr. r31,r3
ffc09070: 40 82 ff 00 bne+ ffc08f70 <pthread_create+0x6c>
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
ffc09074: 3f 00 00 00 lis r24,0
ffc09078: 80 78 28 34 lwz r3,10292(r24)
* _POSIX_Threads_Allocate
*/
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
ffc0907c: 3e e0 00 00 lis r23,0
ffc09080: 3a f7 2e 0c addi r23,r23,11788
ffc09084: 48 00 20 7d bl ffc0b100 <_API_Mutex_Lock>
ffc09088: 7e e3 bb 78 mr r3,r23
ffc0908c: 48 00 2d 65 bl ffc0bdf0 <_Objects_Allocate>
ffc09090: 7e f4 bb 78 mr r20,r23
* Allocate the thread control block.
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
ffc09094: 7c 79 1b 79 mr. r25,r3
ffc09098: 41 82 00 70 beq- ffc09108 <pthread_create+0x204>
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
ffc0909c: 3d 20 00 00 lis r9,0
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
ffc090a0: 80 1e 00 08 lwz r0,8(r30)
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
ffc090a4: 80 c9 27 28 lwz r6,10024(r9)
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
ffc090a8: 93 e1 00 48 stw r31,72(r1)
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
ffc090ac: 54 c6 08 3c rlwinm r6,r6,1,0,30
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
ffc090b0: 7f 86 00 40 cmplw cr7,r6,r0
ffc090b4: 80 be 00 04 lwz r5,4(r30)
ffc090b8: 40 9c 00 08 bge- cr7,ffc090c0 <pthread_create+0x1bc>
ffc090bc: 7c 06 03 78 mr r6,r0
ffc090c0: 80 01 00 18 lwz r0,24(r1)
ffc090c4: 7e 83 a3 78 mr r3,r20
ffc090c8: 81 41 00 1c lwz r10,28(r1)
ffc090cc: 7f 24 cb 78 mr r4,r25
ffc090d0: 90 01 00 08 stw r0,8(r1)
ffc090d4: 38 00 00 00 li r0,0
ffc090d8: 38 e0 00 01 li r7,1
ffc090dc: 90 01 00 0c stw r0,12(r1)
ffc090e0: 7d 16 a8 50 subf r8,r22,r21
ffc090e4: 38 01 00 48 addi r0,r1,72
ffc090e8: 39 20 00 01 li r9,1
ffc090ec: 90 01 00 10 stw r0,16(r1)
ffc090f0: 48 00 44 dd bl ffc0d5cc <_Thread_Initialize>
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
ffc090f4: 2f 83 00 00 cmpwi cr7,r3,0
ffc090f8: 40 9e 00 78 bne- cr7,ffc09170 <pthread_create+0x26c>
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
ffc090fc: 7e e3 bb 78 mr r3,r23
ffc09100: 7f 24 cb 78 mr r4,r25
ffc09104: 48 00 30 e9 bl ffc0c1ec <_Objects_Free>
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
ffc09108: 80 78 28 34 lwz r3,10292(r24)
return EAGAIN;
ffc0910c: 3b e0 00 0b li r31,11
name /* posix threads don't have a name */
);
if ( !status ) {
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
ffc09110: 48 00 20 71 bl ffc0b180 <_API_Mutex_Unlock>
return EAGAIN;
ffc09114: 4b ff fe 5c b ffc08f70 <pthread_create+0x6c>
int rc;
if ( !start_routine )
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
ffc09118: 3f c0 ff c2 lis r30,-62
ffc0911c: 3b de 24 14 addi r30,r30,9236
ffc09120: 4b ff fe 40 b ffc08f60 <pthread_create+0x5c>
* PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
ffc09124: 3d 20 00 00 lis r9,0
ffc09128: 81 29 31 10 lwz r9,12560(r9)
ffc0912c: 81 29 01 34 lwz r9,308(r9)
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
ffc09130: 80 a9 00 88 lwz r5,136(r9)
ffc09134: 80 c9 00 8c lwz r6,140(r9)
ffc09138: 80 e9 00 90 lwz r7,144(r9)
ffc0913c: 81 09 00 94 lwz r8,148(r9)
ffc09140: 81 49 00 98 lwz r10,152(r9)
ffc09144: 81 69 00 9c lwz r11,156(r9)
ffc09148: 80 09 00 a0 lwz r0,160(r9)
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
schedpolicy = api->schedpolicy;
ffc0914c: 83 49 00 84 lwz r26,132(r9)
schedparam = api->schedparam;
ffc09150: 90 a1 00 20 stw r5,32(r1)
ffc09154: 90 c1 00 24 stw r6,36(r1)
ffc09158: 90 e1 00 28 stw r7,40(r1)
ffc0915c: 91 01 00 2c stw r8,44(r1)
ffc09160: 91 41 00 30 stw r10,48(r1)
ffc09164: 91 61 00 34 stw r11,52(r1)
ffc09168: 90 01 00 38 stw r0,56(r1)
break;
ffc0916c: 4b ff fe bc b ffc09028 <pthread_create+0x124>
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
ffc09170: 82 f9 01 34 lwz r23,308(r25)
api->Attributes = *the_attr;
ffc09174: 7f c4 f3 78 mr r4,r30
ffc09178: 38 a0 00 40 li r5,64
ffc0917c: 7e e3 bb 78 mr r3,r23
ffc09180: 48 00 c1 c9 bl ffc15348 <memcpy>
api->detachstate = the_attr->detachstate;
ffc09184: 80 1e 00 3c lwz r0,60(r30)
api->schedpolicy = schedpolicy;
ffc09188: 93 57 00 84 stw r26,132(r23)
api->schedparam = schedparam;
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
ffc0918c: 7f 23 cb 78 mr r3,r25
ffc09190: 38 80 00 01 li r4,1
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->Attributes = *the_attr;
api->detachstate = the_attr->detachstate;
ffc09194: 90 17 00 40 stw r0,64(r23)
api->schedparam = schedparam;
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
ffc09198: 7f 65 db 78 mr r5,r27
ffc0919c: 7f 86 e3 78 mr r6,r28
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->Attributes = *the_attr;
api->detachstate = the_attr->detachstate;
api->schedpolicy = schedpolicy;
api->schedparam = schedparam;
ffc091a0: 80 01 00 20 lwz r0,32(r1)
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
ffc091a4: 38 e0 00 00 li r7,0
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->Attributes = *the_attr;
api->detachstate = the_attr->detachstate;
api->schedpolicy = schedpolicy;
api->schedparam = schedparam;
ffc091a8: 90 17 00 88 stw r0,136(r23)
ffc091ac: 80 01 00 24 lwz r0,36(r1)
ffc091b0: 90 17 00 8c stw r0,140(r23)
ffc091b4: 80 01 00 28 lwz r0,40(r1)
ffc091b8: 90 17 00 90 stw r0,144(r23)
ffc091bc: 80 01 00 2c lwz r0,44(r1)
ffc091c0: 90 17 00 94 stw r0,148(r23)
ffc091c4: 80 01 00 30 lwz r0,48(r1)
ffc091c8: 90 17 00 98 stw r0,152(r23)
ffc091cc: 80 01 00 34 lwz r0,52(r1)
ffc091d0: 90 17 00 9c stw r0,156(r23)
ffc091d4: 80 01 00 38 lwz r0,56(r1)
ffc091d8: 90 17 00 a0 stw r0,160(r23)
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
ffc091dc: 48 00 50 29 bl ffc0e204 <_Thread_Start>
_RTEMS_Unlock_allocator();
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
ffc091e0: 2f 9a 00 04 cmpwi cr7,r26,4
ffc091e4: 41 9e 00 18 beq- cr7,ffc091fc <pthread_create+0x2f8>
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
ffc091e8: 80 19 00 08 lwz r0,8(r25)
_RTEMS_Unlock_allocator();
ffc091ec: 80 78 28 34 lwz r3,10292(r24)
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
ffc091f0: 90 1d 00 00 stw r0,0(r29)
_RTEMS_Unlock_allocator();
ffc091f4: 48 00 1f 8d bl ffc0b180 <_API_Mutex_Unlock>
return 0;
ffc091f8: 4b ff fd 78 b ffc08f70 <pthread_create+0x6c>
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
_Watchdog_Insert_ticks(
ffc091fc: 38 77 00 90 addi r3,r23,144
ffc09200: 48 00 51 5d bl ffc0e35c <_Timespec_To_ticks>
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
ffc09204: 38 97 00 a8 addi r4,r23,168
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
ffc09208: 90 77 00 b4 stw r3,180(r23)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
ffc0920c: 3c 60 00 00 lis r3,0
ffc09210: 38 63 2d 28 addi r3,r3,11560
ffc09214: 48 00 56 e1 bl ffc0e8f4 <_Watchdog_Insert>
ffc09218: 4b ff ff d0 b ffc091e8 <pthread_create+0x2e4>
ffc1f404 <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
ffc1f404: 94 21 ff d8 stwu r1,-40(r1)
ffc1f408: 7c 08 02 a6 mflr r0
ffc1f40c: 93 a1 00 1c stw r29,28(r1)
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
ffc1f410: 7c 9d 23 79 mr. r29,r4
int pthread_kill(
pthread_t thread,
int sig
)
{
ffc1f414: 90 01 00 2c stw r0,44(r1)
ffc1f418: 93 81 00 18 stw r28,24(r1)
ffc1f41c: 93 c1 00 20 stw r30,32(r1)
ffc1f420: 93 e1 00 24 stw r31,36(r1)
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
ffc1f424: 41 82 00 b8 beq- ffc1f4dc <pthread_kill+0xd8>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
ffc1f428: 3b 9d ff ff addi r28,r29,-1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
ffc1f42c: 2b 9c 00 1f cmplwi cr7,r28,31
ffc1f430: 41 9d 00 ac bgt- cr7,ffc1f4dc <pthread_kill+0xd8>
rtems_set_errno_and_return_minus_one( EINVAL );
the_thread = _Thread_Get( thread, &location );
ffc1f434: 38 81 00 08 addi r4,r1,8
ffc1f438: 4b fe d0 ed bl ffc0c524 <_Thread_Get>
switch ( location ) {
ffc1f43c: 80 01 00 08 lwz r0,8(r1)
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
rtems_set_errno_and_return_minus_one( EINVAL );
the_thread = _Thread_Get( thread, &location );
ffc1f440: 7c 7f 1b 78 mr r31,r3
switch ( location ) {
ffc1f444: 2f 80 00 00 cmpwi cr7,r0,0
ffc1f448: 40 9e 00 a8 bne- cr7,ffc1f4f0 <pthread_kill+0xec> <== NEVER TAKEN
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
ffc1f44c: 1c 1d 00 0c mulli r0,r29,12
case OBJECTS_LOCAL:
/*
* If sig == 0 then just validate arguments
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
ffc1f450: 81 23 01 34 lwz r9,308(r3)
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
ffc1f454: 3d 60 00 00 lis r11,0
ffc1f458: 39 6b 31 c0 addi r11,r11,12736
ffc1f45c: 7d 6b 02 14 add r11,r11,r0
ffc1f460: 80 0b 00 08 lwz r0,8(r11)
ffc1f464: 2f 80 00 01 cmpwi cr7,r0,1
ffc1f468: 41 9e 00 44 beq- cr7,ffc1f4ac <pthread_kill+0xa8>
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
ffc1f46c: 80 09 00 d4 lwz r0,212(r9)
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
ffc1f470: 3b c0 00 01 li r30,1
ffc1f474: 7f dc e0 30 slw r28,r30,r28
ffc1f478: 7c 1c e3 78 or r28,r0,r28
ffc1f47c: 93 89 00 d4 stw r28,212(r9)
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
ffc1f480: 7f a4 eb 78 mr r4,r29
ffc1f484: 38 a0 00 00 li r5,0
ffc1f488: 4b ff fe 11 bl ffc1f298 <_POSIX_signals_Unblock_thread>
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
ffc1f48c: 3d 20 00 00 lis r9,0
ffc1f490: 39 29 31 44 addi r9,r9,12612
ffc1f494: 80 09 00 08 lwz r0,8(r9)
ffc1f498: 2f 80 00 00 cmpwi cr7,r0,0
ffc1f49c: 41 9e 00 10 beq- cr7,ffc1f4ac <pthread_kill+0xa8>
ffc1f4a0: 80 09 00 0c lwz r0,12(r9)
ffc1f4a4: 7f 9f 00 00 cmpw cr7,r31,r0
ffc1f4a8: 41 9e 00 2c beq- cr7,ffc1f4d4 <pthread_kill+0xd0>
_Thread_Dispatch_necessary = true;
}
_Thread_Enable_dispatch();
ffc1f4ac: 4b fe d0 3d bl ffc0c4e8 <_Thread_Enable_dispatch>
return 0;
ffc1f4b0: 38 60 00 00 li r3,0
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
}
ffc1f4b4: 80 01 00 2c lwz r0,44(r1)
ffc1f4b8: 83 81 00 18 lwz r28,24(r1)
ffc1f4bc: 7c 08 03 a6 mtlr r0
ffc1f4c0: 83 a1 00 1c lwz r29,28(r1)
ffc1f4c4: 83 c1 00 20 lwz r30,32(r1)
ffc1f4c8: 83 e1 00 24 lwz r31,36(r1)
ffc1f4cc: 38 21 00 28 addi r1,r1,40
ffc1f4d0: 4e 80 00 20 blr
api->signals_pending |= signo_to_mask( sig );
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
ffc1f4d4: 9b c9 00 18 stb r30,24(r9)
ffc1f4d8: 4b ff ff d4 b ffc1f4ac <pthread_kill+0xa8>
if ( !sig )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
rtems_set_errno_and_return_minus_one( EINVAL );
ffc1f4dc: 4b ff 48 b1 bl ffc13d8c <__errno>
ffc1f4e0: 38 00 00 16 li r0,22
ffc1f4e4: 90 03 00 00 stw r0,0(r3)
ffc1f4e8: 38 60 ff ff li r3,-1
ffc1f4ec: 4b ff ff c8 b ffc1f4b4 <pthread_kill+0xb0>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
ffc1f4f0: 4b ff 48 9d bl ffc13d8c <__errno> <== NOT EXECUTED
ffc1f4f4: 38 00 00 03 li r0,3 <== NOT EXECUTED
ffc1f4f8: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1f4fc: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc1f500: 4b ff ff b4 b ffc1f4b4 <pthread_kill+0xb0> <== NOT EXECUTED
ffc0b39c <pthread_mutex_timedlock>:
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
ffc0b39c: 94 21 ff e0 stwu r1,-32(r1)
ffc0b3a0: 7c 08 02 a6 mflr r0
ffc0b3a4: 93 c1 00 18 stw r30,24(r1)
ffc0b3a8: 7c 7e 1b 78 mr r30,r3
*
* 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 );
ffc0b3ac: 7c 83 23 78 mr r3,r4
ffc0b3b0: 38 81 00 08 addi r4,r1,8
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
ffc0b3b4: 93 e1 00 1c stw r31,28(r1)
ffc0b3b8: 90 01 00 24 stw r0,36(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 );
ffc0b3bc: 48 00 01 25 bl ffc0b4e0 <_POSIX_Absolute_timeout_to_ticks>
ffc0b3c0: 7c 7f 1b 78 mr r31,r3
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
ffc0b3c4: 2f 9f 00 03 cmpwi cr7,r31,3
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
ffc0b3c8: 80 a1 00 08 lwz r5,8(r1)
ffc0b3cc: 7f c3 f3 78 mr r3,r30
* 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 );
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
ffc0b3d0: 41 9e 00 2c beq- cr7,ffc0b3fc <pthread_mutex_timedlock+0x60>
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
ffc0b3d4: 38 80 00 00 li r4,0
ffc0b3d8: 4b ff fe 65 bl ffc0b23c <_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) ) {
ffc0b3dc: 2f 83 00 10 cmpwi cr7,r3,16
ffc0b3e0: 41 9e 00 3c beq- cr7,ffc0b41c <pthread_mutex_timedlock+0x80>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return lock_status;
}
ffc0b3e4: 80 01 00 24 lwz r0,36(r1)
ffc0b3e8: 83 c1 00 18 lwz r30,24(r1)
ffc0b3ec: 7c 08 03 a6 mtlr r0
ffc0b3f0: 83 e1 00 1c lwz r31,28(r1)
ffc0b3f4: 38 21 00 20 addi r1,r1,32
ffc0b3f8: 4e 80 00 20 blr
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
ffc0b3fc: 38 80 00 01 li r4,1
ffc0b400: 4b ff fe 3d bl ffc0b23c <_POSIX_Mutex_Lock_support>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return lock_status;
}
ffc0b404: 80 01 00 24 lwz r0,36(r1)
ffc0b408: 83 c1 00 18 lwz r30,24(r1)
ffc0b40c: 7c 08 03 a6 mtlr r0
ffc0b410: 83 e1 00 1c lwz r31,28(r1)
ffc0b414: 38 21 00 20 addi r1,r1,32
ffc0b418: 4e 80 00 20 blr
* 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) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
ffc0b41c: 2f 9f 00 00 cmpwi cr7,r31,0
ffc0b420: 40 9e 00 0c bne- cr7,ffc0b42c <pthread_mutex_timedlock+0x90><== ALWAYS TAKEN
return EINVAL;
ffc0b424: 38 60 00 16 li r3,22 <== NOT EXECUTED
ffc0b428: 4b ff ff bc b ffc0b3e4 <pthread_mutex_timedlock+0x48><== NOT EXECUTED
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
ffc0b42c: 3b ff ff ff addi r31,r31,-1
ffc0b430: 2b 9f 00 01 cmplwi cr7,r31,1
ffc0b434: 41 9d ff b0 bgt+ cr7,ffc0b3e4 <pthread_mutex_timedlock+0x48><== NEVER TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
ffc0b438: 38 60 00 74 li r3,116
ffc0b43c: 4b ff ff a8 b ffc0b3e4 <pthread_mutex_timedlock+0x48>
ffc0984c <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
ffc0984c: 94 21 ff e0 stwu r1,-32(r1)
ffc09850: 7c 08 02 a6 mflr r0
ffc09854: 93 e1 00 1c stw r31,28(r1)
if ( !once_control || !init_routine )
ffc09858: 7c 7f 1b 79 mr. r31,r3
return EINVAL;
ffc0985c: 38 60 00 16 li r3,22
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
ffc09860: 93 c1 00 18 stw r30,24(r1)
ffc09864: 7c 9e 23 78 mr r30,r4
ffc09868: 90 01 00 24 stw r0,36(r1)
if ( !once_control || !init_routine )
ffc0986c: 41 82 00 1c beq- ffc09888 <pthread_once+0x3c>
ffc09870: 2f 84 00 00 cmpwi cr7,r4,0
ffc09874: 41 9e 00 14 beq- cr7,ffc09888 <pthread_once+0x3c>
return EINVAL;
if ( !once_control->init_executed ) {
ffc09878: 80 1f 00 04 lwz r0,4(r31)
once_control->init_executed = true;
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
ffc0987c: 38 60 00 00 li r3,0
)
{
if ( !once_control || !init_routine )
return EINVAL;
if ( !once_control->init_executed ) {
ffc09880: 2f 80 00 00 cmpwi cr7,r0,0
ffc09884: 41 9e 00 1c beq- cr7,ffc098a0 <pthread_once+0x54>
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
}
ffc09888: 80 01 00 24 lwz r0,36(r1)
ffc0988c: 83 c1 00 18 lwz r30,24(r1)
ffc09890: 7c 08 03 a6 mtlr r0
ffc09894: 83 e1 00 1c lwz r31,28(r1)
ffc09898: 38 21 00 20 addi r1,r1,32
ffc0989c: 4e 80 00 20 blr
if ( !once_control || !init_routine )
return EINVAL;
if ( !once_control->init_executed ) {
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
ffc098a0: 38 60 01 00 li r3,256
ffc098a4: 38 80 01 00 li r4,256
ffc098a8: 38 a1 00 08 addi r5,r1,8
ffc098ac: 48 00 0e f1 bl ffc0a79c <rtems_task_mode>
if ( !once_control->init_executed ) {
ffc098b0: 80 1f 00 04 lwz r0,4(r31)
ffc098b4: 2f 80 00 00 cmpwi cr7,r0,0
ffc098b8: 41 9e 00 30 beq- cr7,ffc098e8 <pthread_once+0x9c> <== ALWAYS TAKEN
once_control->is_initialized = true;
once_control->init_executed = true;
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
ffc098bc: 80 61 00 08 lwz r3,8(r1)
ffc098c0: 38 a1 00 08 addi r5,r1,8
ffc098c4: 38 80 01 00 li r4,256
ffc098c8: 48 00 0e d5 bl ffc0a79c <rtems_task_mode>
}
return 0;
}
ffc098cc: 80 01 00 24 lwz r0,36(r1)
once_control->init_executed = true;
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
ffc098d0: 38 60 00 00 li r3,0
}
ffc098d4: 83 c1 00 18 lwz r30,24(r1)
ffc098d8: 7c 08 03 a6 mtlr r0
ffc098dc: 83 e1 00 1c lwz r31,28(r1)
ffc098e0: 38 21 00 20 addi r1,r1,32
ffc098e4: 4e 80 00 20 blr
if ( !once_control->init_executed ) {
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
if ( !once_control->init_executed ) {
once_control->is_initialized = true;
ffc098e8: 38 00 00 01 li r0,1
once_control->init_executed = true;
(*init_routine)();
ffc098ec: 7f c9 03 a6 mtctr r30
if ( !once_control->init_executed ) {
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
if ( !once_control->init_executed ) {
once_control->is_initialized = true;
ffc098f0: 90 1f 00 00 stw r0,0(r31)
once_control->init_executed = true;
ffc098f4: 90 1f 00 04 stw r0,4(r31)
(*init_routine)();
ffc098f8: 4e 80 04 21 bctrl
ffc098fc: 4b ff ff c0 b ffc098bc <pthread_once+0x70>
ffc09fbc <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
ffc09fbc: 94 21 ff d8 stwu r1,-40(r1)
ffc09fc0: 7c 08 02 a6 mflr r0
ffc09fc4: 93 e1 00 24 stw r31,36(r1)
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
ffc09fc8: 7c 7f 1b 79 mr. r31,r3
return EINVAL;
ffc09fcc: 38 60 00 16 li r3,22
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
ffc09fd0: 90 01 00 2c stw r0,44(r1)
ffc09fd4: 93 81 00 18 stw r28,24(r1)
ffc09fd8: 93 a1 00 1c stw r29,28(r1)
ffc09fdc: 93 c1 00 20 stw r30,32(r1)
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
ffc09fe0: 41 82 00 1c beq- ffc09ffc <pthread_rwlock_init+0x40>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
ffc09fe4: 2f 84 00 00 cmpwi cr7,r4,0
ffc09fe8: 41 9e 00 a0 beq- cr7,ffc0a088 <pthread_rwlock_init+0xcc>
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
ffc09fec: 80 04 00 00 lwz r0,0(r4)
return EINVAL;
ffc09ff0: 38 60 00 16 li r3,22
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
ffc09ff4: 2f 80 00 00 cmpwi cr7,r0,0
ffc09ff8: 40 9e 00 24 bne- cr7,ffc0a01c <pthread_rwlock_init+0x60><== ALWAYS TAKEN
*rwlock = the_rwlock->Object.id;
_Thread_Enable_dispatch();
return 0;
}
ffc09ffc: 80 01 00 2c lwz r0,44(r1)
ffc0a000: 83 81 00 18 lwz r28,24(r1)
ffc0a004: 7c 08 03 a6 mtlr r0
ffc0a008: 83 a1 00 1c lwz r29,28(r1)
ffc0a00c: 83 c1 00 20 lwz r30,32(r1)
ffc0a010: 83 e1 00 24 lwz r31,36(r1)
ffc0a014: 38 21 00 28 addi r1,r1,40
ffc0a018: 4e 80 00 20 blr
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
return EINVAL;
switch ( the_attr->process_shared ) {
ffc0a01c: 83 c4 00 04 lwz r30,4(r4)
ffc0a020: 2f 9e 00 00 cmpwi cr7,r30,0
ffc0a024: 40 be ff d8 bne- cr7,ffc09ffc <pthread_rwlock_init+0x40><== NEVER TAKEN
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc0a028: 3d 20 00 00 lis r9,0
*/
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(
CORE_RWLock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
ffc0a02c: 93 c1 00 08 stw r30,8(r1)
ffc0a030: 81 69 28 34 lwz r11,10292(r9)
ffc0a034: 38 0b 00 01 addi r0,r11,1
ffc0a038: 90 09 28 34 stw r0,10292(r9)
return _Thread_Dispatch_disable_level;
ffc0a03c: 80 09 28 34 lwz r0,10292(r9)
* This function allocates a RWLock control block from
* the inactive chain of free RWLock control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Allocate( void )
{
return (POSIX_RWLock_Control *)
ffc0a040: 3f 80 00 00 lis r28,0
ffc0a044: 3b 9c 2d ec addi r28,r28,11756
ffc0a048: 7f 83 e3 78 mr r3,r28
ffc0a04c: 48 00 33 09 bl ffc0d354 <_Objects_Allocate>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
ffc0a050: 7c 7d 1b 79 mr. r29,r3
ffc0a054: 41 82 00 44 beq- ffc0a098 <pthread_rwlock_init+0xdc>
_Thread_Enable_dispatch();
return EAGAIN;
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
ffc0a058: 38 7d 00 10 addi r3,r29,16
ffc0a05c: 38 81 00 08 addi r4,r1,8
ffc0a060: 48 00 27 cd bl ffc0c82c <_CORE_RWLock_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
ffc0a064: 80 1d 00 08 lwz r0,8(r29)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
ffc0a068: 81 7c 00 1c lwz r11,28(r28)
ffc0a06c: 54 09 13 ba rlwinm r9,r0,2,14,29
ffc0a070: 7f ab 49 2e stwx r29,r11,r9
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
ffc0a074: 93 dd 00 0c stw r30,12(r29)
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
ffc0a078: 90 1f 00 00 stw r0,0(r31)
_Thread_Enable_dispatch();
ffc0a07c: 48 00 49 a9 bl ffc0ea24 <_Thread_Enable_dispatch>
return 0;
ffc0a080: 38 60 00 00 li r3,0
ffc0a084: 4b ff ff 78 b ffc09ffc <pthread_rwlock_init+0x40>
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
ffc0a088: 38 61 00 0c addi r3,r1,12
ffc0a08c: 48 00 0c a1 bl ffc0ad2c <pthread_rwlockattr_init>
the_attr = &default_attr;
ffc0a090: 38 81 00 0c addi r4,r1,12
ffc0a094: 4b ff ff 58 b ffc09fec <pthread_rwlock_init+0x30>
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
_Thread_Enable_dispatch();
ffc0a098: 48 00 49 8d bl ffc0ea24 <_Thread_Enable_dispatch>
return EAGAIN;
ffc0a09c: 38 60 00 0b li r3,11
ffc0a0a0: 4b ff ff 5c b ffc09ffc <pthread_rwlock_init+0x40>
ffc0a130 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
ffc0a130: 94 21 ff d8 stwu r1,-40(r1)
ffc0a134: 7c 08 02 a6 mflr r0
ffc0a138: 93 81 00 18 stw r28,24(r1)
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
ffc0a13c: 7c 7c 1b 79 mr. r28,r3
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
ffc0a140: 7c 83 23 78 mr r3,r4
ffc0a144: 93 e1 00 24 stw r31,36(r1)
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
return EINVAL;
ffc0a148: 3b e0 00 16 li r31,22
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
ffc0a14c: 90 01 00 2c stw r0,44(r1)
ffc0a150: 93 a1 00 1c stw r29,28(r1)
ffc0a154: 93 c1 00 20 stw r30,32(r1)
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
ffc0a158: 41 82 00 7c beq- ffc0a1d4 <pthread_rwlock_timedrdlock+0xa4>
*
* 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 );
ffc0a15c: 38 81 00 08 addi r4,r1,8
ffc0a160: 48 00 86 6d bl ffc127cc <_POSIX_Absolute_timeout_to_ticks>
ffc0a164: 80 9c 00 00 lwz r4,0(r28)
ffc0a168: 7c 7e 1b 78 mr r30,r3
ffc0a16c: 3c 60 00 00 lis r3,0
ffc0a170: 38 63 2d ec addi r3,r3,11756
ffc0a174: 38 a1 00 0c addi r5,r1,12
ffc0a178: 48 00 37 cd bl ffc0d944 <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
ffc0a17c: 80 01 00 0c lwz r0,12(r1)
ffc0a180: 2f 80 00 00 cmpwi cr7,r0,0
ffc0a184: 40 9e 00 50 bne- cr7,ffc0a1d4 <pthread_rwlock_timedrdlock+0xa4>
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,
ffc0a188: 6b dd 00 03 xori r29,r30,3
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
ffc0a18c: 80 9c 00 00 lwz r4,0(r28)
ffc0a190: 7f bd 00 34 cntlzw r29,r29
ffc0a194: 80 c1 00 08 lwz r6,8(r1)
ffc0a198: 57 bd d9 7e rlwinm r29,r29,27,5,31
ffc0a19c: 38 63 00 10 addi r3,r3,16
ffc0a1a0: 7f a5 eb 78 mr r5,r29
ffc0a1a4: 38 e0 00 00 li r7,0
ffc0a1a8: 48 00 26 c5 bl ffc0c86c <_CORE_RWLock_Obtain_for_reading>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
ffc0a1ac: 48 00 48 79 bl ffc0ea24 <_Thread_Enable_dispatch>
if ( !do_wait ) {
ffc0a1b0: 2f 9d 00 00 cmpwi cr7,r29,0
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
ffc0a1b4: 3d 20 00 00 lis r9,0
ffc0a1b8: 81 29 31 30 lwz r9,12592(r9)
ffc0a1bc: 80 69 00 34 lwz r3,52(r9)
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
ffc0a1c0: 40 9e 00 0c bne- cr7,ffc0a1cc <pthread_rwlock_timedrdlock+0x9c>
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
ffc0a1c4: 2f 83 00 02 cmpwi cr7,r3,2
ffc0a1c8: 41 9e 00 30 beq- cr7,ffc0a1f8 <pthread_rwlock_timedrdlock+0xc8>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
ffc0a1cc: 48 00 01 2d bl ffc0a2f8 <_POSIX_RWLock_Translate_core_RWLock_return_code>
ffc0a1d0: 7c 7f 1b 78 mr r31,r3
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
ffc0a1d4: 80 01 00 2c lwz r0,44(r1)
ffc0a1d8: 7f e3 fb 78 mr r3,r31
ffc0a1dc: 83 81 00 18 lwz r28,24(r1)
ffc0a1e0: 7c 08 03 a6 mtlr r0
ffc0a1e4: 83 a1 00 1c lwz r29,28(r1)
ffc0a1e8: 83 c1 00 20 lwz r30,32(r1)
ffc0a1ec: 83 e1 00 24 lwz r31,36(r1)
ffc0a1f0: 38 21 00 28 addi r1,r1,40
ffc0a1f4: 4e 80 00 20 blr
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
ffc0a1f8: 2f 9e 00 00 cmpwi cr7,r30,0
ffc0a1fc: 41 9e ff d8 beq+ cr7,ffc0a1d4 <pthread_rwlock_timedrdlock+0xa4><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
ffc0a200: 3b de ff ff addi r30,r30,-1
ffc0a204: 2b 9e 00 01 cmplwi cr7,r30,1
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
ffc0a208: 3b e0 00 74 li r31,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 ||
ffc0a20c: 41 9d ff c0 bgt+ cr7,ffc0a1cc <pthread_rwlock_timedrdlock+0x9c><== NEVER TAKEN
ffc0a210: 4b ff ff c4 b ffc0a1d4 <pthread_rwlock_timedrdlock+0xa4>
ffc0a214 <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
ffc0a214: 94 21 ff d8 stwu r1,-40(r1)
ffc0a218: 7c 08 02 a6 mflr r0
ffc0a21c: 93 81 00 18 stw r28,24(r1)
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
ffc0a220: 7c 7c 1b 79 mr. r28,r3
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
ffc0a224: 7c 83 23 78 mr r3,r4
ffc0a228: 93 e1 00 24 stw r31,36(r1)
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
return EINVAL;
ffc0a22c: 3b e0 00 16 li r31,22
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
ffc0a230: 90 01 00 2c stw r0,44(r1)
ffc0a234: 93 a1 00 1c stw r29,28(r1)
ffc0a238: 93 c1 00 20 stw r30,32(r1)
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
ffc0a23c: 41 82 00 7c beq- ffc0a2b8 <pthread_rwlock_timedwrlock+0xa4>
*
* 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 );
ffc0a240: 38 81 00 08 addi r4,r1,8
ffc0a244: 48 00 85 89 bl ffc127cc <_POSIX_Absolute_timeout_to_ticks>
ffc0a248: 80 9c 00 00 lwz r4,0(r28)
ffc0a24c: 7c 7e 1b 78 mr r30,r3
ffc0a250: 3c 60 00 00 lis r3,0
ffc0a254: 38 63 2d ec addi r3,r3,11756
ffc0a258: 38 a1 00 0c addi r5,r1,12
ffc0a25c: 48 00 36 e9 bl ffc0d944 <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
ffc0a260: 80 01 00 0c lwz r0,12(r1)
ffc0a264: 2f 80 00 00 cmpwi cr7,r0,0
ffc0a268: 40 9e 00 50 bne- cr7,ffc0a2b8 <pthread_rwlock_timedwrlock+0xa4>
(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,
ffc0a26c: 6b dd 00 03 xori r29,r30,3
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
ffc0a270: 80 9c 00 00 lwz r4,0(r28)
ffc0a274: 7f bd 00 34 cntlzw r29,r29
ffc0a278: 80 c1 00 08 lwz r6,8(r1)
ffc0a27c: 57 bd d9 7e rlwinm r29,r29,27,5,31
ffc0a280: 38 63 00 10 addi r3,r3,16
ffc0a284: 7f a5 eb 78 mr r5,r29
ffc0a288: 38 e0 00 00 li r7,0
ffc0a28c: 48 00 27 15 bl ffc0c9a0 <_CORE_RWLock_Obtain_for_writing>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
ffc0a290: 48 00 47 95 bl ffc0ea24 <_Thread_Enable_dispatch>
if ( !do_wait &&
ffc0a294: 2f 9d 00 00 cmpwi cr7,r29,0
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
ffc0a298: 3d 20 00 00 lis r9,0
ffc0a29c: 81 29 31 30 lwz r9,12592(r9)
ffc0a2a0: 80 69 00 34 lwz r3,52(r9)
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
ffc0a2a4: 40 9e 00 0c bne- cr7,ffc0a2b0 <pthread_rwlock_timedwrlock+0x9c>
ffc0a2a8: 2f 83 00 02 cmpwi cr7,r3,2
ffc0a2ac: 41 9e 00 30 beq- cr7,ffc0a2dc <pthread_rwlock_timedwrlock+0xc8>
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
ffc0a2b0: 48 00 00 49 bl ffc0a2f8 <_POSIX_RWLock_Translate_core_RWLock_return_code>
ffc0a2b4: 7c 7f 1b 78 mr r31,r3
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
ffc0a2b8: 80 01 00 2c lwz r0,44(r1)
ffc0a2bc: 7f e3 fb 78 mr r3,r31
ffc0a2c0: 83 81 00 18 lwz r28,24(r1)
ffc0a2c4: 7c 08 03 a6 mtlr r0
ffc0a2c8: 83 a1 00 1c lwz r29,28(r1)
ffc0a2cc: 83 c1 00 20 lwz r30,32(r1)
ffc0a2d0: 83 e1 00 24 lwz r31,36(r1)
ffc0a2d4: 38 21 00 28 addi r1,r1,40
ffc0a2d8: 4e 80 00 20 blr
);
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
ffc0a2dc: 2f 9e 00 00 cmpwi cr7,r30,0
ffc0a2e0: 41 9e ff d8 beq+ cr7,ffc0a2b8 <pthread_rwlock_timedwrlock+0xa4><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
ffc0a2e4: 3b de ff ff addi r30,r30,-1
ffc0a2e8: 2b 9e 00 01 cmplwi cr7,r30,1
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
ffc0a2ec: 3b e0 00 74 li r31,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 ||
ffc0a2f0: 41 9d ff c0 bgt+ cr7,ffc0a2b0 <pthread_rwlock_timedwrlock+0x9c><== NEVER TAKEN
ffc0a2f4: 4b ff ff c4 b ffc0a2b8 <pthread_rwlock_timedwrlock+0xa4>
ffc0bfbc <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
ffc0bfbc: 94 21 ff d0 stwu r1,-48(r1)
ffc0bfc0: 7c 08 02 a6 mflr r0
ffc0bfc4: 93 e1 00 2c stw r31,44(r1)
int rc;
/*
* Check all the parameters
*/
if ( !param )
ffc0bfc8: 7c bf 2b 79 mr. r31,r5
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
ffc0bfcc: 93 81 00 20 stw r28,32(r1)
/*
* Check all the parameters
*/
if ( !param )
return EINVAL;
ffc0bfd0: 3b 80 00 16 li r28,22
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
ffc0bfd4: 93 a1 00 24 stw r29,36(r1)
ffc0bfd8: 7c 7d 1b 78 mr r29,r3
ffc0bfdc: 93 c1 00 28 stw r30,40(r1)
ffc0bfe0: 7c 9e 23 78 mr r30,r4
ffc0bfe4: 90 01 00 34 stw r0,52(r1)
ffc0bfe8: 93 61 00 1c stw r27,28(r1)
int rc;
/*
* Check all the parameters
*/
if ( !param )
ffc0bfec: 41 82 00 20 beq- ffc0c00c <pthread_setschedparam+0x50>
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
ffc0bff0: 7c 83 23 78 mr r3,r4
ffc0bff4: 38 a1 00 10 addi r5,r1,16
ffc0bff8: 7f e4 fb 78 mr r4,r31
ffc0bffc: 38 c1 00 0c addi r6,r1,12
ffc0c000: 48 00 7a 79 bl ffc13a78 <_POSIX_Thread_Translate_sched_param>
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
ffc0c004: 7c 7c 1b 79 mr. r28,r3
ffc0c008: 41 82 00 2c beq- ffc0c034 <pthread_setschedparam+0x78>
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
ffc0c00c: 80 01 00 34 lwz r0,52(r1)
ffc0c010: 7f 83 e3 78 mr r3,r28
ffc0c014: 83 61 00 1c lwz r27,28(r1)
ffc0c018: 7c 08 03 a6 mtlr r0
ffc0c01c: 83 81 00 20 lwz r28,32(r1)
ffc0c020: 83 a1 00 24 lwz r29,36(r1)
ffc0c024: 83 c1 00 28 lwz r30,40(r1)
ffc0c028: 83 e1 00 2c lwz r31,44(r1)
ffc0c02c: 38 21 00 30 addi r1,r1,48
ffc0c030: 4e 80 00 20 blr
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
ffc0c034: 7f a3 eb 78 mr r3,r29
ffc0c038: 38 81 00 08 addi r4,r1,8
ffc0c03c: 48 00 3a 99 bl ffc0fad4 <_Thread_Get>
switch ( location ) {
ffc0c040: 80 01 00 08 lwz r0,8(r1)
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
ffc0c044: 7c 7b 1b 78 mr r27,r3
switch ( location ) {
ffc0c048: 2f 80 00 00 cmpwi cr7,r0,0
ffc0c04c: 40 9e 00 98 bne- cr7,ffc0c0e4 <pthread_setschedparam+0x128>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
ffc0c050: 83 a3 01 34 lwz r29,308(r3)
if ( api->schedpolicy == SCHED_SPORADIC )
ffc0c054: 80 1d 00 84 lwz r0,132(r29)
ffc0c058: 2f 80 00 04 cmpwi cr7,r0,4
ffc0c05c: 41 9e 00 e4 beq- cr7,ffc0c140 <pthread_setschedparam+0x184>
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
ffc0c060: 93 dd 00 84 stw r30,132(r29)
api->schedparam = *param;
the_thread->budget_algorithm = budget_algorithm;
the_thread->budget_callout = budget_callout;
switch ( api->schedpolicy ) {
ffc0c064: 2f 9e 00 00 cmpwi cr7,r30,0
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
api->schedparam = *param;
ffc0c068: 81 5f 00 04 lwz r10,4(r31)
ffc0c06c: 81 7f 00 08 lwz r11,8(r31)
ffc0c070: 81 3f 00 0c lwz r9,12(r31)
ffc0c074: 80 1f 00 00 lwz r0,0(r31)
ffc0c078: 91 5d 00 8c stw r10,140(r29)
ffc0c07c: 90 1d 00 88 stw r0,136(r29)
ffc0c080: 91 7d 00 90 stw r11,144(r29)
ffc0c084: 91 3d 00 94 stw r9,148(r29)
ffc0c088: 81 3f 00 18 lwz r9,24(r31)
ffc0c08c: 81 5f 00 10 lwz r10,16(r31)
ffc0c090: 81 7f 00 14 lwz r11,20(r31)
ffc0c094: 91 3d 00 a0 stw r9,160(r29)
the_thread->budget_algorithm = budget_algorithm;
ffc0c098: 81 21 00 10 lwz r9,16(r1)
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
api->schedparam = *param;
ffc0c09c: 91 5d 00 98 stw r10,152(r29)
ffc0c0a0: 91 7d 00 9c stw r11,156(r29)
the_thread->budget_algorithm = budget_algorithm;
ffc0c0a4: 91 3b 00 7c stw r9,124(r27)
the_thread->budget_callout = budget_callout;
ffc0c0a8: 81 21 00 0c lwz r9,12(r1)
ffc0c0ac: 91 3b 00 80 stw r9,128(r27)
switch ( api->schedpolicy ) {
ffc0c0b0: 41 9c 00 2c blt- cr7,ffc0c0dc <pthread_setschedparam+0x120><== NEVER TAKEN
ffc0c0b4: 2f 9e 00 02 cmpwi cr7,r30,2
ffc0c0b8: 40 9d 00 58 ble- cr7,ffc0c110 <pthread_setschedparam+0x154>
ffc0c0bc: 2f 9e 00 04 cmpwi cr7,r30,4
ffc0c0c0: 40 be 00 1c bne+ cr7,ffc0c0dc <pthread_setschedparam+0x120><== NEVER TAKEN
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
ffc0c0c4: 90 1d 00 a4 stw r0,164(r29)
_Watchdog_Remove( &api->Sporadic_timer );
ffc0c0c8: 38 7d 00 a8 addi r3,r29,168
ffc0c0cc: 48 00 51 11 bl ffc111dc <_Watchdog_Remove>
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
ffc0c0d0: 38 60 00 00 li r3,0
ffc0c0d4: 7f 64 db 78 mr r4,r27
ffc0c0d8: 4b ff fd 3d bl ffc0be14 <_POSIX_Threads_Sporadic_budget_TSR>
break;
}
_Thread_Enable_dispatch();
ffc0c0dc: 48 00 39 bd bl ffc0fa98 <_Thread_Enable_dispatch>
return 0;
ffc0c0e0: 4b ff ff 2c b ffc0c00c <pthread_setschedparam+0x50>
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
ffc0c0e4: 80 01 00 34 lwz r0,52(r1)
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
ffc0c0e8: 3b 80 00 03 li r28,3
}
ffc0c0ec: 7f 83 e3 78 mr r3,r28
ffc0c0f0: 83 61 00 1c lwz r27,28(r1)
ffc0c0f4: 7c 08 03 a6 mtlr r0
ffc0c0f8: 83 81 00 20 lwz r28,32(r1)
ffc0c0fc: 83 a1 00 24 lwz r29,36(r1)
ffc0c100: 83 c1 00 28 lwz r30,40(r1)
ffc0c104: 83 e1 00 2c lwz r31,44(r1)
ffc0c108: 38 21 00 30 addi r1,r1,48
ffc0c10c: 4e 80 00 20 blr
ffc0c110: 3d 20 00 00 lis r9,0
ffc0c114: 88 89 27 64 lbz r4,10084(r9)
switch ( api->schedpolicy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
ffc0c118: 3d 20 00 00 lis r9,0
ffc0c11c: 81 29 28 84 lwz r9,10372(r9)
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
ffc0c120: 7f 63 db 78 mr r3,r27
ffc0c124: 7c 80 20 50 subf r4,r0,r4
switch ( api->schedpolicy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
ffc0c128: 91 3b 00 78 stw r9,120(r27)
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
ffc0c12c: 38 a0 00 01 li r5,1
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
the_thread->real_priority =
ffc0c130: 90 9b 00 18 stw r4,24(r27)
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
ffc0c134: 48 00 33 41 bl ffc0f474 <_Thread_Change_priority>
_Watchdog_Remove( &api->Sporadic_timer );
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
break;
}
_Thread_Enable_dispatch();
ffc0c138: 48 00 39 61 bl ffc0fa98 <_Thread_Enable_dispatch>
ffc0c13c: 4b ff fe d0 b ffc0c00c <pthread_setschedparam+0x50>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
ffc0c140: 38 7d 00 a8 addi r3,r29,168
ffc0c144: 48 00 50 99 bl ffc111dc <_Watchdog_Remove>
ffc0c148: 4b ff ff 18 b ffc0c060 <pthread_setschedparam+0xa4>
ffc11880 <pthread_sigmask>:
sigset_t *oset
)
{
POSIX_API_Control *api;
if ( !set && !oset )
ffc11880: 2c 04 00 00 cmpwi r4,0
int pthread_sigmask(
int how,
const sigset_t *set,
sigset_t *oset
)
{
ffc11884: 94 21 ff f0 stwu r1,-16(r1)
ffc11888: 7c 08 02 a6 mflr r0
POSIX_API_Control *api;
if ( !set && !oset )
ffc1188c: 2f 85 00 00 cmpwi cr7,r5,0
int pthread_sigmask(
int how,
const sigset_t *set,
sigset_t *oset
)
{
ffc11890: 90 01 00 14 stw r0,20(r1)
POSIX_API_Control *api;
if ( !set && !oset )
ffc11894: 41 82 00 c0 beq- ffc11954 <pthread_sigmask+0xd4>
rtems_set_errno_and_return_minus_one( EINVAL );
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
ffc11898: 3d 20 00 00 lis r9,0
ffc1189c: 81 29 31 90 lwz r9,12688(r9)
ffc118a0: 81 29 01 34 lwz r9,308(r9)
if ( oset )
ffc118a4: 41 9e 00 10 beq- cr7,ffc118b4 <pthread_sigmask+0x34>
*oset = api->signals_blocked;
ffc118a8: 80 09 00 d0 lwz r0,208(r9)
ffc118ac: 90 05 00 00 stw r0,0(r5)
if ( !set )
ffc118b0: 41 82 00 c0 beq- ffc11970 <pthread_sigmask+0xf0> <== NEVER TAKEN
return 0;
switch ( how ) {
ffc118b4: 2f 83 00 01 cmpwi cr7,r3,1
ffc118b8: 41 9e 00 88 beq- cr7,ffc11940 <pthread_sigmask+0xc0>
ffc118bc: 2f 83 00 02 cmpwi cr7,r3,2
ffc118c0: 41 9e 00 4c beq- cr7,ffc1190c <pthread_sigmask+0x8c>
ffc118c4: 2f 83 00 00 cmpwi cr7,r3,0
ffc118c8: 40 9e 00 58 bne- cr7,ffc11920 <pthread_sigmask+0xa0>
break;
case SIG_UNBLOCK:
api->signals_blocked &= ~*set;
break;
case SIG_SETMASK:
api->signals_blocked = *set;
ffc118cc: 80 04 00 00 lwz r0,0(r4)
ffc118d0: 90 09 00 d0 stw r0,208(r9)
/* XXX are there critical section problems here? */
/* XXX evaluate the new set */
if ( ~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending) ) {
ffc118d4: 3d 60 00 00 lis r11,0
ffc118d8: 81 29 00 d4 lwz r9,212(r9)
ffc118dc: 81 6b 28 bc lwz r11,10428(r11)
_Thread_Dispatch();
}
return 0;
ffc118e0: 38 60 00 00 li r3,0
/* XXX are there critical section problems here? */
/* XXX evaluate the new set */
if ( ~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending) ) {
ffc118e4: 7d 69 4b 78 or r9,r11,r9
/* XXX are there critical section problems here? */
/* XXX evaluate the new set */
if ( ~api->signals_blocked &
ffc118e8: 7d 2b 00 79 andc. r11,r9,r0
ffc118ec: 41 a2 00 10 beq+ ffc118fc <pthread_sigmask+0x7c>
(api->signals_pending | _POSIX_signals_Pending) ) {
_Thread_Dispatch();
ffc118f0: 90 61 00 08 stw r3,8(r1)
ffc118f4: 4b ff b8 99 bl ffc0d18c <_Thread_Dispatch>
ffc118f8: 80 61 00 08 lwz r3,8(r1)
}
return 0;
}
ffc118fc: 80 01 00 14 lwz r0,20(r1)
ffc11900: 38 21 00 10 addi r1,r1,16
ffc11904: 7c 08 03 a6 mtlr r0
ffc11908: 4e 80 00 20 blr
switch ( how ) {
case SIG_BLOCK:
api->signals_blocked |= *set;
break;
case SIG_UNBLOCK:
api->signals_blocked &= ~*set;
ffc1190c: 81 64 00 00 lwz r11,0(r4)
ffc11910: 80 09 00 d0 lwz r0,208(r9)
ffc11914: 7c 00 58 78 andc r0,r0,r11
ffc11918: 90 09 00 d0 stw r0,208(r9)
break;
ffc1191c: 4b ff ff b8 b ffc118d4 <pthread_sigmask+0x54>
case SIG_SETMASK:
api->signals_blocked = *set;
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
ffc11920: 48 00 33 91 bl ffc14cb0 <__errno>
ffc11924: 38 00 00 16 li r0,22
ffc11928: 90 03 00 00 stw r0,0(r3)
ffc1192c: 38 60 ff ff li r3,-1
(api->signals_pending | _POSIX_signals_Pending) ) {
_Thread_Dispatch();
}
return 0;
}
ffc11930: 80 01 00 14 lwz r0,20(r1)
ffc11934: 38 21 00 10 addi r1,r1,16
ffc11938: 7c 08 03 a6 mtlr r0
ffc1193c: 4e 80 00 20 blr
if ( !set )
return 0;
switch ( how ) {
case SIG_BLOCK:
api->signals_blocked |= *set;
ffc11940: 80 09 00 d0 lwz r0,208(r9)
ffc11944: 81 64 00 00 lwz r11,0(r4)
ffc11948: 7c 00 5b 78 or r0,r0,r11
ffc1194c: 90 09 00 d0 stw r0,208(r9)
break;
ffc11950: 4b ff ff 84 b ffc118d4 <pthread_sigmask+0x54>
sigset_t *oset
)
{
POSIX_API_Control *api;
if ( !set && !oset )
ffc11954: 41 be ff cc beq- cr7,ffc11920 <pthread_sigmask+0xa0>
rtems_set_errno_and_return_minus_one( EINVAL );
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
ffc11958: 3d 20 00 00 lis r9,0
ffc1195c: 81 29 31 90 lwz r9,12688(r9)
ffc11960: 81 29 01 34 lwz r9,308(r9)
if ( oset )
*oset = api->signals_blocked;
ffc11964: 80 09 00 d0 lwz r0,208(r9)
ffc11968: 90 05 00 00 stw r0,0(r5)
if ( !set )
ffc1196c: 40 82 ff 48 bne+ ffc118b4 <pthread_sigmask+0x34> <== NEVER TAKEN
(api->signals_pending | _POSIX_signals_Pending) ) {
_Thread_Dispatch();
}
return 0;
}
ffc11970: 80 01 00 14 lwz r0,20(r1)
if ( oset )
*oset = api->signals_blocked;
if ( !set )
return 0;
ffc11974: 38 60 00 00 li r3,0
(api->signals_pending | _POSIX_signals_Pending) ) {
_Thread_Dispatch();
}
return 0;
}
ffc11978: 38 21 00 10 addi r1,r1,16
ffc1197c: 7c 08 03 a6 mtlr r0
ffc11980: 4e 80 00 20 blr
ffc0953c <pthread_testcancel>:
/*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
ffc0953c: 94 21 ff f0 stwu r1,-16(r1)
ffc09540: 7c 08 02 a6 mflr r0
ffc09544: 93 e1 00 0c stw r31,12(r1)
* 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() )
ffc09548: 3f e0 00 00 lis r31,0
ffc0954c: 3b ff 31 04 addi r31,r31,12548
/*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
ffc09550: 90 01 00 14 stw r0,20(r1)
* 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() )
ffc09554: 80 1f 00 08 lwz r0,8(r31)
ffc09558: 2f 80 00 00 cmpwi cr7,r0,0
ffc0955c: 40 9e 00 48 bne- cr7,ffc095a4 <pthread_testcancel+0x68> <== NEVER TAKEN
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc09560: 3d 20 00 00 lis r9,0
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
ffc09564: 81 7f 00 0c lwz r11,12(r31)
ffc09568: 81 49 28 0c lwz r10,10252(r9)
ffc0956c: 81 6b 01 34 lwz r11,308(r11)
ffc09570: 38 0a 00 01 addi r0,r10,1
ffc09574: 90 09 28 0c stw r0,10252(r9)
return _Thread_Dispatch_disable_level;
ffc09578: 80 09 28 0c lwz r0,10252(r9)
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
ffc0957c: 80 0b 00 d8 lwz r0,216(r11)
ffc09580: 2f 80 00 00 cmpwi cr7,r0,0
ffc09584: 40 9e 00 34 bne- cr7,ffc095b8 <pthread_testcancel+0x7c> <== NEVER TAKEN
ffc09588: 80 0b 00 e0 lwz r0,224(r11)
ffc0958c: 2f 80 00 00 cmpwi cr7,r0,0
ffc09590: 41 9e 00 28 beq- cr7,ffc095b8 <pthread_testcancel+0x7c>
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
ffc09594: 48 00 38 51 bl ffc0cde4 <_Thread_Enable_dispatch>
if ( cancel )
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
ffc09598: 80 7f 00 0c lwz r3,12(r31)
ffc0959c: 38 80 ff ff li r4,-1
ffc095a0: 48 00 79 31 bl ffc10ed0 <_POSIX_Thread_Exit>
}
ffc095a4: 80 01 00 14 lwz r0,20(r1) <== NOT EXECUTED
ffc095a8: 83 e1 00 0c lwz r31,12(r1) <== NOT EXECUTED
ffc095ac: 38 21 00 10 addi r1,r1,16 <== NOT EXECUTED
ffc095b0: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc095b4: 4e 80 00 20 blr <== NOT EXECUTED
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
ffc095b8: 48 00 38 2d bl ffc0cde4 <_Thread_Enable_dispatch>
if ( cancel )
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
}
ffc095bc: 80 01 00 14 lwz r0,20(r1)
ffc095c0: 83 e1 00 0c lwz r31,12(r1)
ffc095c4: 38 21 00 10 addi r1,r1,16
ffc095c8: 7c 08 03 a6 mtlr r0
ffc095cc: 4e 80 00 20 blr
ffc0ed2c <ramdisk_allocate>:
void *area_begin,
uint32_t block_size,
rtems_blkdev_bnum block_count,
bool trace
)
{
ffc0ed2c: 94 21 ff e0 stwu r1,-32(r1)
ffc0ed30: 7c 08 02 a6 mflr r0
ffc0ed34: 93 e1 00 1c stw r31,28(r1)
ffc0ed38: 7c 7f 1b 78 mr r31,r3
struct ramdisk *rd = malloc(sizeof(struct ramdisk));
ffc0ed3c: 38 60 00 10 li r3,16
void *area_begin,
uint32_t block_size,
rtems_blkdev_bnum block_count,
bool trace
)
{
ffc0ed40: 93 61 00 0c stw r27,12(r1)
ffc0ed44: 7c db 33 78 mr r27,r6
ffc0ed48: 93 81 00 10 stw r28,16(r1)
ffc0ed4c: 93 a1 00 14 stw r29,20(r1)
ffc0ed50: 7c bd 2b 78 mr r29,r5
ffc0ed54: 93 c1 00 18 stw r30,24(r1)
ffc0ed58: 7c 9e 23 78 mr r30,r4
ffc0ed5c: 90 01 00 24 stw r0,36(r1)
struct ramdisk *rd = malloc(sizeof(struct ramdisk));
ffc0ed60: 4b ff 73 d9 bl ffc06138 <malloc>
if (rd == NULL) {
ffc0ed64: 7c 7c 1b 79 mr. r28,r3
ffc0ed68: 41 82 00 2c beq- ffc0ed94 <ramdisk_allocate+0x68> <== NEVER TAKEN
return NULL;
}
if (area_begin == NULL) {
ffc0ed6c: 2f 9f 00 00 cmpwi cr7,r31,0
ffc0ed70: 41 9e 00 4c beq- cr7,ffc0edbc <ramdisk_allocate+0x90> <== ALWAYS TAKEN
return NULL;
}
rd->malloced = true;
} else {
rd->malloced = false;
ffc0ed74: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc0ed78: 98 1c 00 0d stb r0,13(r28) <== NOT EXECUTED
}
rd->block_size = block_size;
rd->block_num = block_count;
rd->area = area_begin;
rd->trace = trace;
rd->initialized = true;
ffc0ed7c: 38 00 00 01 li r0,1
}
rd->malloced = true;
} else {
rd->malloced = false;
}
rd->block_size = block_size;
ffc0ed80: 93 dc 00 00 stw r30,0(r28)
rd->block_num = block_count;
ffc0ed84: 93 bc 00 04 stw r29,4(r28)
rd->area = area_begin;
ffc0ed88: 93 fc 00 08 stw r31,8(r28)
rd->trace = trace;
ffc0ed8c: 9b 7c 00 0e stb r27,14(r28)
rd->initialized = true;
ffc0ed90: 98 1c 00 0c stb r0,12(r28)
return rd;
}
ffc0ed94: 80 01 00 24 lwz r0,36(r1)
ffc0ed98: 7f 83 e3 78 mr r3,r28
ffc0ed9c: 83 61 00 0c lwz r27,12(r1)
ffc0eda0: 7c 08 03 a6 mtlr r0
ffc0eda4: 83 81 00 10 lwz r28,16(r1)
ffc0eda8: 83 a1 00 14 lwz r29,20(r1)
ffc0edac: 83 c1 00 18 lwz r30,24(r1)
ffc0edb0: 83 e1 00 1c lwz r31,28(r1)
ffc0edb4: 38 21 00 20 addi r1,r1,32
ffc0edb8: 4e 80 00 20 blr
if (rd == NULL) {
return NULL;
}
if (area_begin == NULL) {
area_begin = calloc(block_count, block_size);
ffc0edbc: 7f a3 eb 78 mr r3,r29
ffc0edc0: 7f c4 f3 78 mr r4,r30
ffc0edc4: 4b ff 6c ad bl ffc05a70 <calloc>
if (area_begin == NULL) {
ffc0edc8: 7c 7f 1b 79 mr. r31,r3
ffc0edcc: 41 82 00 10 beq- ffc0eddc <ramdisk_allocate+0xb0> <== NEVER TAKEN
free(rd);
return NULL;
}
rd->malloced = true;
ffc0edd0: 38 00 00 01 li r0,1
ffc0edd4: 98 1c 00 0d stb r0,13(r28)
ffc0edd8: 4b ff ff a4 b ffc0ed7c <ramdisk_allocate+0x50>
}
if (area_begin == NULL) {
area_begin = calloc(block_count, block_size);
if (area_begin == NULL) {
free(rd);
ffc0eddc: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc0ede0: 4b ff 6f 3d bl ffc05d1c <free> <== NOT EXECUTED
return NULL;
ffc0ede4: 3b 80 00 00 li r28,0 <== NOT EXECUTED
ffc0ede8: 4b ff ff ac b ffc0ed94 <ramdisk_allocate+0x68> <== NOT EXECUTED
ffc0edec <ramdisk_free>:
return rd;
}
void ramdisk_free(ramdisk *rd)
{
ffc0edec: 94 21 ff f0 stwu r1,-16(r1)
ffc0edf0: 7c 08 02 a6 mflr r0
ffc0edf4: 93 e1 00 0c stw r31,12(r1)
if (rd != NULL) {
ffc0edf8: 7c 7f 1b 79 mr. r31,r3
return rd;
}
void ramdisk_free(ramdisk *rd)
{
ffc0edfc: 90 01 00 14 stw r0,20(r1)
if (rd != NULL) {
ffc0ee00: 41 82 00 18 beq- ffc0ee18 <ramdisk_free+0x2c> <== NEVER TAKEN
if (rd->malloced) {
ffc0ee04: 88 1f 00 0d lbz r0,13(r31)
ffc0ee08: 2f 80 00 00 cmpwi cr7,r0,0
ffc0ee0c: 40 9e 00 20 bne- cr7,ffc0ee2c <ramdisk_free+0x40> <== ALWAYS TAKEN
free(rd->area);
}
free(rd);
ffc0ee10: 7f e3 fb 78 mr r3,r31
ffc0ee14: 4b ff 6f 09 bl ffc05d1c <free>
}
}
ffc0ee18: 80 01 00 14 lwz r0,20(r1)
ffc0ee1c: 83 e1 00 0c lwz r31,12(r1)
ffc0ee20: 38 21 00 10 addi r1,r1,16
ffc0ee24: 7c 08 03 a6 mtlr r0
ffc0ee28: 4e 80 00 20 blr
void ramdisk_free(ramdisk *rd)
{
if (rd != NULL) {
if (rd->malloced) {
free(rd->area);
ffc0ee2c: 80 7f 00 08 lwz r3,8(r31)
ffc0ee30: 4b ff 6e ed bl ffc05d1c <free>
ffc0ee34: 4b ff ff dc b ffc0ee10 <ramdisk_free+0x24>
ffc0eb8c <ramdisk_ioctl>:
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
ffc0eb8c: 94 21 ff e0 stwu r1,-32(r1)
ffc0eb90: 7c 08 02 a6 mflr r0
ffc0eb94: 90 01 00 24 stw r0,36(r1)
switch (req)
ffc0eb98: 3c 00 c0 18 lis r0,-16360
ffc0eb9c: 60 00 42 01 ori r0,r0,16897
ffc0eba0: 7f 84 00 00 cmpw cr7,r4,r0
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
ffc0eba4: 93 c1 00 18 stw r30,24(r1)
ffc0eba8: 7c be 2b 78 mr r30,r5
ffc0ebac: 93 61 00 0c stw r27,12(r1)
ffc0ebb0: 93 81 00 10 stw r28,16(r1)
ffc0ebb4: 93 a1 00 14 stw r29,20(r1)
ffc0ebb8: 93 e1 00 1c stw r31,28(r1)
switch (req)
ffc0ebbc: 41 9e 00 2c beq- cr7,ffc0ebe8 <ramdisk_ioctl+0x5c>
}
break;
}
default:
return rtems_blkdev_ioctl (dd, req, argp);
ffc0ebc0: 48 00 35 79 bl ffc12138 <rtems_blkdev_ioctl>
break;
}
errno = EINVAL;
return -1;
}
ffc0ebc4: 80 01 00 24 lwz r0,36(r1)
ffc0ebc8: 83 61 00 0c lwz r27,12(r1)
ffc0ebcc: 7c 08 03 a6 mtlr r0
ffc0ebd0: 83 81 00 10 lwz r28,16(r1)
ffc0ebd4: 83 a1 00 14 lwz r29,20(r1)
ffc0ebd8: 83 c1 00 18 lwz r30,24(r1)
ffc0ebdc: 83 e1 00 1c lwz r31,28(r1)
ffc0ebe0: 38 21 00 20 addi r1,r1,32
ffc0ebe4: 4e 80 00 20 blr
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (r->req)
ffc0ebe8: 80 05 00 00 lwz r0,0(r5)
break;
}
errno = EINVAL;
return -1;
}
ffc0ebec: 83 83 00 2c lwz r28,44(r3)
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (r->req)
ffc0ebf0: 2f 80 00 00 cmpwi cr7,r0,0
ffc0ebf4: 40 9e 00 90 bne- cr7,ffc0ec84 <ramdisk_ioctl+0xf8>
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
ffc0ebf8: 80 05 00 10 lwz r0,16(r5)
break;
}
errno = EINVAL;
return -1;
}
ffc0ebfc: 83 7c 00 08 lwz r27,8(r28)
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
ffc0ec00: 2f 80 00 00 cmpwi cr7,r0,0
ffc0ec04: 41 9e 00 3c beq- cr7,ffc0ec40 <ramdisk_ioctl+0xb4> <== NEVER TAKEN
ffc0ec08: 3b e5 00 18 addi r31,r5,24
ffc0ec0c: 3b a0 00 00 li r29,0
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: buf=%d block=%d length=%d off=%d addr=%p",
i, sg->block, sg->length, sg->block * rd->block_size,
from + (sg->block * rd->block_size));
#endif
memcpy(sg->buffer, from + (sg->block * rd->block_size), sg->length);
ffc0ec10: 80 9f 00 00 lwz r4,0(r31)
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
ffc0ec14: 3b bd 00 01 addi r29,r29,1
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: buf=%d block=%d length=%d off=%d addr=%p",
i, sg->block, sg->length, sg->block * rd->block_size,
from + (sg->block * rd->block_size));
#endif
memcpy(sg->buffer, from + (sg->block * rd->block_size), sg->length);
ffc0ec18: 80 1c 00 00 lwz r0,0(r28)
ffc0ec1c: 80 7f 00 08 lwz r3,8(r31)
ffc0ec20: 7c 84 01 d6 mullw r4,r4,r0
ffc0ec24: 80 bf 00 04 lwz r5,4(r31)
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
ffc0ec28: 3b ff 00 10 addi r31,r31,16
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: buf=%d block=%d length=%d off=%d addr=%p",
i, sg->block, sg->length, sg->block * rd->block_size,
from + (sg->block * rd->block_size));
#endif
memcpy(sg->buffer, from + (sg->block * rd->block_size), sg->length);
ffc0ec2c: 7c 9b 22 14 add r4,r27,r4
ffc0ec30: 48 00 a5 1d bl ffc1914c <memcpy>
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
ffc0ec34: 80 1e 00 10 lwz r0,16(r30)
ffc0ec38: 7f 9d 00 40 cmplw cr7,r29,r0
ffc0ec3c: 41 9c ff d4 blt+ cr7,ffc0ec10 <ramdisk_ioctl+0x84> <== NEVER TAKEN
i, sg->block, sg->length, sg->block * rd->block_size,
to + (sg->block * rd->block_size));
#endif
memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);
}
req->status = RTEMS_SUCCESSFUL;
ffc0ec40: 38 00 00 00 li r0,0
req->req_done(req->done_arg, RTEMS_SUCCESSFUL);
ffc0ec44: 80 7e 00 08 lwz r3,8(r30)
i, sg->block, sg->length, sg->block * rd->block_size,
to + (sg->block * rd->block_size));
#endif
memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);
}
req->status = RTEMS_SUCCESSFUL;
ffc0ec48: 90 1e 00 0c stw r0,12(r30)
req->req_done(req->done_arg, RTEMS_SUCCESSFUL);
ffc0ec4c: 38 80 00 00 li r4,0
ffc0ec50: 80 1e 00 04 lwz r0,4(r30)
ffc0ec54: 7c 09 03 a6 mtctr r0
ffc0ec58: 4e 80 04 21 bctrl
{
case RTEMS_BLKDEV_REQ_READ:
return ramdisk_read(rd, r);
case RTEMS_BLKDEV_REQ_WRITE:
return ramdisk_write(rd, r);
ffc0ec5c: 38 60 00 00 li r3,0
break;
}
errno = EINVAL;
return -1;
}
ffc0ec60: 80 01 00 24 lwz r0,36(r1)
ffc0ec64: 83 61 00 0c lwz r27,12(r1)
ffc0ec68: 7c 08 03 a6 mtlr r0
ffc0ec6c: 83 81 00 10 lwz r28,16(r1)
ffc0ec70: 83 a1 00 14 lwz r29,20(r1)
ffc0ec74: 83 c1 00 18 lwz r30,24(r1)
ffc0ec78: 83 e1 00 1c lwz r31,28(r1)
ffc0ec7c: 38 21 00 20 addi r1,r1,32
ffc0ec80: 4e 80 00 20 blr
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (r->req)
ffc0ec84: 2f 80 00 01 cmpwi cr7,r0,1
ffc0ec88: 41 9e 00 38 beq- cr7,ffc0ecc0 <ramdisk_ioctl+0x134> <== ALWAYS TAKEN
case RTEMS_BLKDEV_REQ_WRITE:
return ramdisk_write(rd, r);
default:
errno = EINVAL;
ffc0ec8c: 48 00 98 95 bl ffc18520 <__errno> <== NOT EXECUTED
ffc0ec90: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc0ec94: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
return -1;
ffc0ec98: 38 60 ff ff li r3,-1 <== NOT EXECUTED
break;
}
errno = EINVAL;
return -1;
}
ffc0ec9c: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
ffc0eca0: 83 61 00 0c lwz r27,12(r1) <== NOT EXECUTED
ffc0eca4: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc0eca8: 83 81 00 10 lwz r28,16(r1) <== NOT EXECUTED
ffc0ecac: 83 a1 00 14 lwz r29,20(r1) <== NOT EXECUTED
ffc0ecb0: 83 c1 00 18 lwz r30,24(r1) <== NOT EXECUTED
ffc0ecb4: 83 e1 00 1c lwz r31,28(r1) <== NOT EXECUTED
ffc0ecb8: 38 21 00 20 addi r1,r1,32 <== NOT EXECUTED
ffc0ecbc: 4e 80 00 20 blr <== NOT EXECUTED
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
ffc0ecc0: 80 05 00 10 lwz r0,16(r5)
break;
}
errno = EINVAL;
return -1;
}
ffc0ecc4: 83 7c 00 08 lwz r27,8(r28)
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
ffc0ecc8: 2f 80 00 00 cmpwi cr7,r0,0
ffc0eccc: 41 be ff 74 beq- cr7,ffc0ec40 <ramdisk_ioctl+0xb4> <== NEVER TAKEN
ffc0ecd0: 3b e5 00 18 addi r31,r5,24
ffc0ecd4: 3b a0 00 00 li r29,0
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: buf=%d block=%d length=%d off=%d addr=%p",
i, sg->block, sg->length, sg->block * rd->block_size,
to + (sg->block * rd->block_size));
#endif
memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);
ffc0ecd8: 80 7f 00 00 lwz r3,0(r31)
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
ffc0ecdc: 3b bd 00 01 addi r29,r29,1
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: buf=%d block=%d length=%d off=%d addr=%p",
i, sg->block, sg->length, sg->block * rd->block_size,
to + (sg->block * rd->block_size));
#endif
memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);
ffc0ece0: 80 1c 00 00 lwz r0,0(r28)
ffc0ece4: 80 9f 00 08 lwz r4,8(r31)
ffc0ece8: 7c 63 01 d6 mullw r3,r3,r0
ffc0ecec: 80 bf 00 04 lwz r5,4(r31)
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
ffc0ecf0: 3b ff 00 10 addi r31,r31,16
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: buf=%d block=%d length=%d off=%d addr=%p",
i, sg->block, sg->length, sg->block * rd->block_size,
to + (sg->block * rd->block_size));
#endif
memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);
ffc0ecf4: 7c 7b 1a 14 add r3,r27,r3
ffc0ecf8: 48 00 a4 55 bl ffc1914c <memcpy>
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
ffc0ecfc: 80 1e 00 10 lwz r0,16(r30)
ffc0ed00: 7f 9d 00 40 cmplw cr7,r29,r0
ffc0ed04: 41 9c ff d4 blt+ cr7,ffc0ecd8 <ramdisk_ioctl+0x14c>
i, sg->block, sg->length, sg->block * rd->block_size,
to + (sg->block * rd->block_size));
#endif
memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);
}
req->status = RTEMS_SUCCESSFUL;
ffc0ed08: 38 00 00 00 li r0,0
req->req_done(req->done_arg, RTEMS_SUCCESSFUL);
ffc0ed0c: 80 7e 00 08 lwz r3,8(r30)
i, sg->block, sg->length, sg->block * rd->block_size,
to + (sg->block * rd->block_size));
#endif
memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);
}
req->status = RTEMS_SUCCESSFUL;
ffc0ed10: 90 1e 00 0c stw r0,12(r30)
req->req_done(req->done_arg, RTEMS_SUCCESSFUL);
ffc0ed14: 38 80 00 00 li r4,0
ffc0ed18: 80 1e 00 04 lwz r0,4(r30)
ffc0ed1c: 7c 09 03 a6 mtctr r0
ffc0ed20: 4e 80 04 21 bctrl
{
case RTEMS_BLKDEV_REQ_READ:
return ramdisk_read(rd, r);
case RTEMS_BLKDEV_REQ_WRITE:
return ramdisk_write(rd, r);
ffc0ed24: 38 60 00 00 li r3,0
ffc0ed28: 4b ff ff 38 b ffc0ec60 <ramdisk_ioctl+0xd4>
ffc0ee38 <ramdisk_register>:
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
ffc0ee38: 94 21 ff c8 stwu r1,-56(r1)
ffc0ee3c: 7c 08 02 a6 mflr r0
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
ffc0ee40: 7c 29 0b 78 mr r9,r1
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
ffc0ee44: 90 01 00 3c stw r0,60(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
ffc0ee48: 38 00 00 00 li r0,0
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
ffc0ee4c: 93 21 00 1c stw r25,28(r1)
ffc0ee50: 7c 79 1b 78 mr r25,r3
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
ffc0ee54: 38 60 00 00 li r3,0
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
ffc0ee58: 93 41 00 20 stw r26,32(r1)
ffc0ee5c: 7c 9a 23 78 mr r26,r4
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
ffc0ee60: 3c 80 ff c2 lis r4,-62
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
ffc0ee64: 93 61 00 24 stw r27,36(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
ffc0ee68: 38 84 ef 68 addi r4,r4,-4248
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
ffc0ee6c: 7c db 33 78 mr r27,r6
ffc0ee70: 93 a1 00 2c stw r29,44(r1)
ffc0ee74: 7c bd 2b 78 mr r29,r5
ffc0ee78: 93 c1 00 30 stw r30,48(r1)
ffc0ee7c: 7c fe 3b 78 mr r30,r7
ffc0ee80: 93 e1 00 34 stw r31,52(r1)
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
if (sc != RTEMS_SUCCESSFUL) {
return RTEMS_UNSATISFIED;
ffc0ee84: 3b e0 00 0d li r31,13
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
ffc0ee88: 93 81 00 28 stw r28,40(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
ffc0ee8c: 94 09 00 08 stwu r0,8(r9)
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
ffc0ee90: 7d 25 4b 78 mr r5,r9
ffc0ee94: 4b ff bd ad bl ffc0ac40 <rtems_io_register_driver>
if (sc != RTEMS_SUCCESSFUL) {
ffc0ee98: 2f 83 00 00 cmpwi cr7,r3,0
ffc0ee9c: 41 9e 00 34 beq- cr7,ffc0eed0 <ramdisk_register+0x98> <== ALWAYS TAKEN
}
*dev_ptr = dev;
return RTEMS_SUCCESSFUL;
}
ffc0eea0: 80 01 00 3c lwz r0,60(r1)
ffc0eea4: 7f e3 fb 78 mr r3,r31
ffc0eea8: 83 21 00 1c lwz r25,28(r1)
ffc0eeac: 7c 08 03 a6 mtlr r0
ffc0eeb0: 83 41 00 20 lwz r26,32(r1)
ffc0eeb4: 83 61 00 24 lwz r27,36(r1)
ffc0eeb8: 83 81 00 28 lwz r28,40(r1)
ffc0eebc: 83 a1 00 2c lwz r29,44(r1)
ffc0eec0: 83 c1 00 30 lwz r30,48(r1)
ffc0eec4: 83 e1 00 34 lwz r31,52(r1)
ffc0eec8: 38 21 00 38 addi r1,r1,56
ffc0eecc: 4e 80 00 20 blr
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
if (sc != RTEMS_SUCCESSFUL) {
return RTEMS_UNSATISFIED;
}
rd = ramdisk_allocate(NULL, block_size, block_count, trace);
ffc0eed0: 7f a6 eb 78 mr r6,r29
ffc0eed4: 7f 24 cb 78 mr r4,r25
ffc0eed8: 7f 45 d3 78 mr r5,r26
ffc0eedc: 4b ff fe 51 bl ffc0ed2c <ramdisk_allocate>
if (rd == NULL) {
ffc0eee0: 7c 7d 1b 79 mr. r29,r3
ffc0eee4: 41 82 00 4c beq- ffc0ef30 <ramdisk_register+0xf8> <== NEVER TAKEN
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
ffc0eee8: 83 81 00 08 lwz r28,8(r1)
return RTEMS_UNSATISFIED;
}
dev = rtems_filesystem_make_dev_t(major, 0);
sc = rtems_disk_create_phys(
ffc0eeec: 3c e0 ff c1 lis r7,-63
ffc0eef0: 38 80 00 00 li r4,0
ffc0eef4: 7f 83 e3 78 mr r3,r28
ffc0eef8: 7f 25 cb 78 mr r5,r25
ffc0eefc: 7f 46 d3 78 mr r6,r26
ffc0ef00: 38 e7 eb 8c addi r7,r7,-5236
ffc0ef04: 7f a8 eb 78 mr r8,r29
ffc0ef08: 7f 69 db 78 mr r9,r27
ffc0ef0c: 4b ff 58 29 bl ffc04734 <rtems_disk_create_phys>
block_count,
ramdisk_ioctl,
rd,
disk
);
if (sc != RTEMS_SUCCESSFUL) {
ffc0ef10: 2c 03 00 00 cmpwi r3,0
ffc0ef14: 40 82 00 14 bne- ffc0ef28 <ramdisk_register+0xf0> <== NEVER TAKEN
rtems_io_unregister_driver(major);
return RTEMS_UNSATISFIED;
}
*dev_ptr = dev;
ffc0ef18: 93 9e 00 00 stw r28,0(r30)
return RTEMS_SUCCESSFUL;
ffc0ef1c: 3b e0 00 00 li r31,0
rtems_io_unregister_driver(major);
return RTEMS_UNSATISFIED;
}
*dev_ptr = dev;
ffc0ef20: 90 7e 00 04 stw r3,4(r30)
return RTEMS_SUCCESSFUL;
ffc0ef24: 4b ff ff 7c b ffc0eea0 <ramdisk_register+0x68>
ramdisk_ioctl,
rd,
disk
);
if (sc != RTEMS_SUCCESSFUL) {
ramdisk_free(rd);
ffc0ef28: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc0ef2c: 4b ff fe c1 bl ffc0edec <ramdisk_free> <== NOT EXECUTED
rtems_io_unregister_driver(major);
ffc0ef30: 80 61 00 08 lwz r3,8(r1) <== NOT EXECUTED
ffc0ef34: 4b ff be 99 bl ffc0adcc <rtems_io_unregister_driver> <== NOT EXECUTED
}
*dev_ptr = dev;
return RTEMS_SUCCESSFUL;
}
ffc0ef38: 80 01 00 3c lwz r0,60(r1) <== NOT EXECUTED
ffc0ef3c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc0ef40: 83 21 00 1c lwz r25,28(r1) <== NOT EXECUTED
ffc0ef44: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc0ef48: 83 41 00 20 lwz r26,32(r1) <== NOT EXECUTED
ffc0ef4c: 83 61 00 24 lwz r27,36(r1) <== NOT EXECUTED
ffc0ef50: 83 81 00 28 lwz r28,40(r1) <== NOT EXECUTED
ffc0ef54: 83 a1 00 2c lwz r29,44(r1) <== NOT EXECUTED
ffc0ef58: 83 c1 00 30 lwz r30,48(r1) <== NOT EXECUTED
ffc0ef5c: 83 e1 00 34 lwz r31,52(r1) <== NOT EXECUTED
ffc0ef60: 38 21 00 38 addi r1,r1,56 <== NOT EXECUTED
ffc0ef64: 4e 80 00 20 blr <== NOT EXECUTED
ffc1eb7c <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
ffc1eb7c: 94 21 ff f0 stwu r1,-16(r1)
ffc1eb80: 7c 08 02 a6 mflr r0
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
ffc1eb84: 3d 20 00 00 lis r9,0
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
ffc1eb88: 90 01 00 14 stw r0,20(r1)
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
ffc1eb8c: 80 09 27 3c lwz r0,10044(r9)
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
ffc1eb90: 93 e1 00 0c stw r31,12(r1)
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
ffc1eb94: 7f 83 00 40 cmplw cr7,r3,r0
ffc1eb98: 40 9c 00 8c bge- cr7,ffc1ec24 <read+0xa8>
iop = rtems_libio_iop( fd );
ffc1eb9c: 3d 60 00 00 lis r11,0
ffc1eba0: 83 eb 27 f0 lwz r31,10224(r11)
ffc1eba4: 54 63 30 32 rlwinm r3,r3,6,0,25
ffc1eba8: 7f ff 1a 14 add r31,r31,r3
rtems_libio_check_is_open( iop );
ffc1ebac: 81 7f 00 18 lwz r11,24(r31)
ffc1ebb0: 71 6a 01 00 andi. r10,r11,256
ffc1ebb4: 41 82 00 70 beq- ffc1ec24 <read+0xa8>
rtems_libio_check_buffer( buffer );
ffc1ebb8: 2f 84 00 00 cmpwi cr7,r4,0
ffc1ebbc: 41 9e 00 7c beq- cr7,ffc1ec38 <read+0xbc> <== NEVER TAKEN
rtems_libio_check_count( count );
ffc1ebc0: 2f 85 00 00 cmpwi cr7,r5,0
ffc1ebc4: 38 60 00 00 li r3,0
ffc1ebc8: 41 9e 00 48 beq- cr7,ffc1ec10 <read+0x94>
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
ffc1ebcc: 71 60 00 02 andi. r0,r11,2
ffc1ebd0: 41 82 00 54 beq- ffc1ec24 <read+0xa8>
/*
* Now process the read().
*/
rc = (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
ffc1ebd4: 81 3f 00 24 lwz r9,36(r31)
ffc1ebd8: 7f e3 fb 78 mr r3,r31
ffc1ebdc: 80 09 00 08 lwz r0,8(r9)
ffc1ebe0: 7c 09 03 a6 mtctr r0
ffc1ebe4: 4e 80 04 21 bctrl
if ( rc > 0 )
ffc1ebe8: 2c 03 00 00 cmpwi r3,0
ffc1ebec: 40 81 00 24 ble- ffc1ec10 <read+0x94>
iop->offset += rc;
ffc1ebf0: 81 1f 00 10 lwz r8,16(r31)
ffc1ebf4: 7c 6b 1b 78 mr r11,r3
ffc1ebf8: 81 3f 00 14 lwz r9,20(r31)
ffc1ebfc: 7c 6a fe 70 srawi r10,r3,31
ffc1ec00: 7d 6b 48 14 addc r11,r11,r9
ffc1ec04: 7d 4a 41 14 adde r10,r10,r8
ffc1ec08: 91 5f 00 10 stw r10,16(r31)
ffc1ec0c: 91 7f 00 14 stw r11,20(r31)
return rc;
}
ffc1ec10: 80 01 00 14 lwz r0,20(r1)
ffc1ec14: 83 e1 00 0c lwz r31,12(r1)
ffc1ec18: 38 21 00 10 addi r1,r1,16
ffc1ec1c: 7c 08 03 a6 mtlr r0
ffc1ec20: 4e 80 00 20 blr
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
ffc1ec24: 4b ff 51 69 bl ffc13d8c <__errno>
ffc1ec28: 38 00 00 09 li r0,9
ffc1ec2c: 90 03 00 00 stw r0,0(r3)
ffc1ec30: 38 60 ff ff li r3,-1
ffc1ec34: 4b ff ff dc b ffc1ec10 <read+0x94>
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
ffc1ec38: 4b ff 51 55 bl ffc13d8c <__errno> <== NOT EXECUTED
ffc1ec3c: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc1ec40: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1ec44: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc1ec48: 4b ff ff c8 b ffc1ec10 <read+0x94> <== NOT EXECUTED
ffc078ec <readlink>:
ssize_t readlink(
const char *pathname,
char *buf,
size_t bufsize
)
{
ffc078ec: 94 21 ff c8 stwu r1,-56(r1)
ffc078f0: 7c 08 02 a6 mflr r0
ffc078f4: 93 c1 00 30 stw r30,48(r1)
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
ffc078f8: 7c 9e 23 79 mr. r30,r4
ssize_t readlink(
const char *pathname,
char *buf,
size_t bufsize
)
{
ffc078fc: 93 a1 00 2c stw r29,44(r1)
ffc07900: 7c 7d 1b 78 mr r29,r3
ffc07904: 93 e1 00 34 stw r31,52(r1)
ffc07908: 7c bf 2b 78 mr r31,r5
ffc0790c: 90 01 00 3c stw r0,60(r1)
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
ffc07910: 41 82 00 a4 beq- ffc079b4 <readlink+0xc8>
rtems_set_errno_and_return_minus_one( EFAULT );
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
ffc07914: 48 00 f2 59 bl ffc16b6c <strlen>
ffc07918: 38 a0 00 00 li r5,0
ffc0791c: 7c 64 1b 78 mr r4,r3
ffc07920: 38 c1 00 08 addi r6,r1,8
ffc07924: 7f a3 eb 78 mr r3,r29
ffc07928: 38 e0 00 00 li r7,0
ffc0792c: 4b ff e4 25 bl ffc05d50 <rtems_filesystem_evaluate_path>
0, &loc, false );
if ( result != 0 )
return -1;
ffc07930: 3b a0 ff ff li r29,-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 )
ffc07934: 2f 83 00 00 cmpwi cr7,r3,0
ffc07938: 40 9e 00 48 bne- cr7,ffc07980 <readlink+0x94> <== NEVER TAKEN
return -1;
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){
ffc0793c: 81 21 00 14 lwz r9,20(r1)
ffc07940: 38 61 00 08 addi r3,r1,8
ffc07944: 80 09 00 10 lwz r0,16(r9)
ffc07948: 7c 09 03 a6 mtctr r0
ffc0794c: 4e 80 04 21 bctrl
ffc07950: 2f 83 00 04 cmpwi cr7,r3,4
rtems_filesystem_freenode( &loc );
ffc07954: 38 61 00 08 addi r3,r1,8
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
0, &loc, false );
if ( result != 0 )
return -1;
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){
ffc07958: 40 9e 00 48 bne- cr7,ffc079a0 <readlink+0xb4>
rtems_filesystem_freenode( &loc );
rtems_set_errno_and_return_minus_one( EINVAL );
}
result = (*loc.ops->readlink_h)( &loc, buf, bufsize );
ffc0795c: 81 21 00 14 lwz r9,20(r1)
ffc07960: 7f c4 f3 78 mr r4,r30
ffc07964: 7f e5 fb 78 mr r5,r31
ffc07968: 80 09 00 3c lwz r0,60(r9)
ffc0796c: 7c 09 03 a6 mtctr r0
ffc07970: 4e 80 04 21 bctrl
ffc07974: 7c 7d 1b 78 mr r29,r3
rtems_filesystem_freenode( &loc );
ffc07978: 38 61 00 08 addi r3,r1,8
ffc0797c: 4b ff e6 b5 bl ffc06030 <rtems_filesystem_freenode>
return result;
}
ffc07980: 80 01 00 3c lwz r0,60(r1)
ffc07984: 7f a3 eb 78 mr r3,r29
ffc07988: 83 c1 00 30 lwz r30,48(r1)
ffc0798c: 7c 08 03 a6 mtlr r0
ffc07990: 83 a1 00 2c lwz r29,44(r1)
ffc07994: 83 e1 00 34 lwz r31,52(r1)
ffc07998: 38 21 00 38 addi r1,r1,56
ffc0799c: 4e 80 00 20 blr
0, &loc, false );
if ( result != 0 )
return -1;
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){
rtems_filesystem_freenode( &loc );
ffc079a0: 4b ff e6 91 bl ffc06030 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EINVAL );
ffc079a4: 48 00 db 05 bl ffc154a8 <__errno>
ffc079a8: 38 00 00 16 li r0,22
ffc079ac: 90 03 00 00 stw r0,0(r3)
ffc079b0: 4b ff ff d0 b ffc07980 <readlink+0x94>
{
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
rtems_set_errno_and_return_minus_one( EFAULT );
ffc079b4: 48 00 da f5 bl ffc154a8 <__errno>
ffc079b8: 38 00 00 0e li r0,14
ffc079bc: 90 03 00 00 stw r0,0(r3)
ffc079c0: 3b a0 ff ff li r29,-1
ffc079c4: 4b ff ff bc b ffc07980 <readlink+0x94>
ffc071b0 <readv>:
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
ffc071b0: 94 21 ff d8 stwu r1,-40(r1)
ffc071b4: 7c 08 02 a6 mflr r0
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
ffc071b8: 3d 20 00 00 lis r9,0
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
ffc071bc: 90 01 00 2c stw r0,44(r1)
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
ffc071c0: 80 09 27 1c lwz r0,10012(r9)
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
ffc071c4: 93 a1 00 1c stw r29,28(r1)
ffc071c8: 7c 9d 23 78 mr r29,r4
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
ffc071cc: 7f 83 00 40 cmplw cr7,r3,r0
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
ffc071d0: 93 01 00 08 stw r24,8(r1)
ffc071d4: 93 21 00 0c stw r25,12(r1)
ffc071d8: 93 41 00 10 stw r26,16(r1)
ffc071dc: 93 61 00 14 stw r27,20(r1)
ffc071e0: 93 81 00 18 stw r28,24(r1)
ffc071e4: 93 c1 00 20 stw r30,32(r1)
ffc071e8: 93 e1 00 24 stw r31,36(r1)
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
ffc071ec: 40 9c 01 60 bge- cr7,ffc0734c <readv+0x19c>
iop = rtems_libio_iop( fd );
ffc071f0: 3d 20 00 00 lis r9,0
ffc071f4: 83 69 27 cc lwz r27,10188(r9)
ffc071f8: 54 63 30 32 rlwinm r3,r3,6,0,25
ffc071fc: 7f 7b 1a 14 add r27,r27,r3
rtems_libio_check_is_open( iop );
ffc07200: 80 1b 00 18 lwz r0,24(r27)
ffc07204: 70 09 01 00 andi. r9,r0,256
ffc07208: 41 82 01 44 beq- ffc0734c <readv+0x19c>
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
ffc0720c: 70 09 00 02 andi. r9,r0,2
ffc07210: 41 82 01 3c beq- ffc0734c <readv+0x19c> <== NEVER TAKEN
/*
* Argument validation on IO vector
*/
if ( !iov )
ffc07214: 2f 84 00 00 cmpwi cr7,r4,0
ffc07218: 41 9e 00 f0 beq- cr7,ffc07308 <readv+0x158>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
ffc0721c: 2f 85 00 00 cmpwi cr7,r5,0
ffc07220: 40 9d 00 e8 ble- cr7,ffc07308 <readv+0x158>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
ffc07224: 2f 85 04 00 cmpwi cr7,r5,1024
ffc07228: 41 9d 00 e0 bgt- cr7,ffc07308 <readv+0x158> <== NEVER TAKEN
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t readv(
ffc0722c: 54 b8 18 38 rlwinm r24,r5,3,0,28
ffc07230: 39 78 ff f8 addi r11,r24,-8
ffc07234: 55 6b e8 fe rlwinm r11,r11,29,3,31
ffc07238: 39 6b 00 01 addi r11,r11,1
ffc0723c: 7d 69 03 a6 mtctr r11
ffc07240: 39 20 00 00 li r9,0
ffc07244: 39 00 00 01 li r8,1
ffc07248: 38 00 00 00 li r0,0
/*
* 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 )
ffc0724c: 7d 7d 48 2e lwzx r11,r29,r9
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t readv(
ffc07250: 7d 5d 4a 14 add r10,r29,r9
old = total;
total += iov[v].iov_len;
if ( total < old )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
ffc07254: 39 29 00 08 addi r9,r9,8
/*
* 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 )
ffc07258: 2f 8b 00 00 cmpwi cr7,r11,0
ffc0725c: 41 9e 00 ac beq- cr7,ffc07308 <readv+0x158>
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
ffc07260: 81 4a 00 04 lwz r10,4(r10)
ffc07264: 7d 6a 02 14 add r11,r10,r0
if ( total < old )
ffc07268: 7f 8b 00 00 cmpw cr7,r11,r0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
all_zeros = false;
ffc0726c: 31 4a ff ff addic r10,r10,-1
ffc07270: 7d 4a 51 10 subfe r10,r10,r10
ffc07274: 7d 08 50 38 and r8,r8,r10
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
ffc07278: 7d 60 5b 78 mr r0,r11
if ( total < old )
ffc0727c: 41 9c 00 8c blt- cr7,ffc07308 <readv+0x158>
* 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++ ) {
ffc07280: 42 00 ff cc bdnz+ ffc0724c <readv+0x9c>
/*
* 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 ) {
ffc07284: 2f 88 00 00 cmpwi cr7,r8,0
return 0;
ffc07288: 3b 20 00 00 li r25,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 ) {
ffc0728c: 40 9e 00 8c bne- cr7,ffc07318 <readv+0x168>
ffc07290: 3b 80 00 00 li r28,0
ffc07294: 48 00 00 3c b ffc072d0 <readv+0x120>
);
if ( bytes < 0 )
return -1;
if ( bytes > 0 ) {
ffc07298: 41 82 00 28 beq- ffc072c0 <readv+0x110> <== NEVER TAKEN
iop->offset += bytes;
ffc0729c: 81 5b 00 10 lwz r10,16(r27)
ffc072a0: 7c 7f 1b 78 mr r31,r3
ffc072a4: 81 7b 00 14 lwz r11,20(r27)
ffc072a8: 7c 7e fe 70 srawi r30,r3,31
total += bytes;
ffc072ac: 7f 39 1a 14 add r25,r25,r3
if ( bytes < 0 )
return -1;
if ( bytes > 0 ) {
iop->offset += bytes;
ffc072b0: 7d 6b f8 14 addc r11,r11,r31
ffc072b4: 7d 4a f1 14 adde r10,r10,r30
ffc072b8: 91 5b 00 10 stw r10,16(r27)
ffc072bc: 91 7b 00 14 stw r11,20(r27)
total += bytes;
}
if (bytes != iov[ v ].iov_len)
ffc072c0: 80 1a 00 04 lwz r0,4(r26)
ffc072c4: 7f 03 00 00 cmpw cr6,r3,r0
ffc072c8: 40 9a 00 50 bne- cr6,ffc07318 <readv+0x168> <== NEVER TAKEN
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
ffc072cc: 41 9e 00 4c beq- cr7,ffc07318 <readv+0x168>
bytes = (*iop->pathinfo.handlers->read_h)(
ffc072d0: 81 3b 00 24 lwz r9,36(r27)
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t readv(
ffc072d4: 7f 5d e2 14 add r26,r29,r28
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
bytes = (*iop->pathinfo.handlers->read_h)(
ffc072d8: 7c 9d e0 2e lwzx r4,r29,r28
ffc072dc: 7f 63 db 78 mr r3,r27
ffc072e0: 80 09 00 08 lwz r0,8(r9)
if ( bytes > 0 ) {
iop->offset += bytes;
total += bytes;
}
if (bytes != iov[ v ].iov_len)
ffc072e4: 3b 9c 00 08 addi r28,r28,8
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
bytes = (*iop->pathinfo.handlers->read_h)(
ffc072e8: 80 ba 00 04 lwz r5,4(r26)
ffc072ec: 7c 09 03 a6 mtctr r0
ffc072f0: 4e 80 04 21 bctrl
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
ffc072f4: 7f 9c c0 00 cmpw cr7,r28,r24
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
ffc072f8: 2c 03 00 00 cmpwi r3,0
ffc072fc: 40 80 ff 9c bge+ ffc07298 <readv+0xe8> <== ALWAYS TAKEN
return -1;
ffc07300: 3b 20 ff ff li r25,-1 <== NOT EXECUTED
ffc07304: 48 00 00 14 b ffc07318 <readv+0x168> <== NOT EXECUTED
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old )
rtems_set_errno_and_return_minus_one( EINVAL );
ffc07308: 48 00 d5 85 bl ffc1488c <__errno>
ffc0730c: 38 00 00 16 li r0,22
ffc07310: 90 03 00 00 stw r0,0(r3)
ffc07314: 3b 20 ff ff li r25,-1
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
ffc07318: 80 01 00 2c lwz r0,44(r1)
ffc0731c: 7f 23 cb 78 mr r3,r25
ffc07320: 83 01 00 08 lwz r24,8(r1)
ffc07324: 7c 08 03 a6 mtlr r0
ffc07328: 83 21 00 0c lwz r25,12(r1)
ffc0732c: 83 41 00 10 lwz r26,16(r1)
ffc07330: 83 61 00 14 lwz r27,20(r1)
ffc07334: 83 81 00 18 lwz r28,24(r1)
ffc07338: 83 a1 00 1c lwz r29,28(r1)
ffc0733c: 83 c1 00 20 lwz r30,32(r1)
ffc07340: 83 e1 00 24 lwz r31,36(r1)
ffc07344: 38 21 00 28 addi r1,r1,40
ffc07348: 4e 80 00 20 blr
bool all_zeros;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
ffc0734c: 48 00 d5 41 bl ffc1488c <__errno>
ffc07350: 38 00 00 09 li r0,9
ffc07354: 90 03 00 00 stw r0,0(r3)
ffc07358: 3b 20 ff ff li r25,-1
ffc0735c: 4b ff ff bc b ffc07318 <readv+0x168>
ffc1ecdc <realloc>:
void *realloc(
void *ptr,
size_t size
)
{
ffc1ecdc: 94 21 ff d8 stwu r1,-40(r1)
ffc1ece0: 7c 08 02 a6 mflr r0
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
ffc1ece4: 3d 20 00 00 lis r9,0
void *realloc(
void *ptr,
size_t size
)
{
ffc1ece8: 90 01 00 2c stw r0,44(r1)
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
ffc1ecec: 80 09 28 48 lwz r0,10312(r9)
void *realloc(
void *ptr,
size_t size
)
{
ffc1ecf0: 93 c1 00 20 stw r30,32(r1)
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
ffc1ecf4: 3f c0 00 00 lis r30,0
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
ffc1ecf8: 2f 80 00 03 cmpwi cr7,r0,3
)
{
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
ffc1ecfc: 3b de 2b 60 addi r30,r30,11104
void *realloc(
void *ptr,
size_t size
)
{
ffc1ed00: 93 a1 00 1c stw r29,28(r1)
ffc1ed04: 7c 9d 23 78 mr r29,r4
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
ffc1ed08: 81 3e 00 10 lwz r9,16(r30)
void *realloc(
void *ptr,
size_t size
)
{
ffc1ed0c: 93 e1 00 24 stw r31,36(r1)
ffc1ed10: 7c 7f 1b 78 mr r31,r3
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
ffc1ed14: 39 29 00 01 addi r9,r9,1
void *realloc(
void *ptr,
size_t size
)
{
ffc1ed18: 93 81 00 18 stw r28,24(r1)
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
ffc1ed1c: 91 3e 00 10 stw r9,16(r30)
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
ffc1ed20: 41 9e 00 d4 beq- cr7,ffc1edf4 <realloc+0x118> <== ALWAYS TAKEN
}
/*
* Continue with realloc().
*/
if ( !ptr )
ffc1ed24: 2f 9f 00 00 cmpwi cr7,r31,0
ffc1ed28: 41 9e 01 58 beq- cr7,ffc1ee80 <realloc+0x1a4>
return malloc( size );
if ( !size ) {
ffc1ed2c: 2f 9d 00 00 cmpwi cr7,r29,0
ffc1ed30: 41 9e 01 2c beq- cr7,ffc1ee5c <realloc+0x180> <== NEVER TAKEN
free( ptr );
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
ffc1ed34: 3f 80 00 00 lis r28,0
ffc1ed38: 80 7c 27 2c lwz r3,10028(r28)
ffc1ed3c: 7f e4 fb 78 mr r4,r31
ffc1ed40: 38 a1 00 08 addi r5,r1,8
ffc1ed44: 48 00 07 d1 bl ffc1f514 <_Protected_heap_Get_block_size>
ffc1ed48: 2f 83 00 00 cmpwi cr7,r3,0
ffc1ed4c: 41 9e 01 20 beq- cr7,ffc1ee6c <realloc+0x190>
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
ffc1ed50: 80 7c 27 2c lwz r3,10028(r28)
ffc1ed54: 7f e4 fb 78 mr r4,r31
ffc1ed58: 7f a5 eb 78 mr r5,r29
ffc1ed5c: 48 00 08 1d bl ffc1f578 <_Protected_heap_Resize_block>
ffc1ed60: 2f 83 00 00 cmpwi cr7,r3,0
ffc1ed64: 41 9e 00 28 beq- cr7,ffc1ed8c <realloc+0xb0>
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
ffc1ed68: 80 01 00 2c lwz r0,44(r1)
ffc1ed6c: 7f e3 fb 78 mr r3,r31
ffc1ed70: 83 81 00 18 lwz r28,24(r1)
ffc1ed74: 7c 08 03 a6 mtlr r0
ffc1ed78: 83 a1 00 1c lwz r29,28(r1)
ffc1ed7c: 83 c1 00 20 lwz r30,32(r1)
ffc1ed80: 83 e1 00 24 lwz r31,36(r1)
ffc1ed84: 38 21 00 28 addi r1,r1,40
ffc1ed88: 4e 80 00 20 blr
* 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 );
ffc1ed8c: 7f a3 eb 78 mr r3,r29
ffc1ed90: 4b fe 68 29 bl ffc055b8 <malloc>
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
ffc1ed94: 81 3e 00 04 lwz r9,4(r30)
if ( !new_area ) {
ffc1ed98: 7c 7c 1b 79 mr. r28,r3
* and the C Standard.
*/
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
ffc1ed9c: 38 09 ff ff addi r0,r9,-1
ffc1eda0: 90 1e 00 04 stw r0,4(r30)
if ( !new_area ) {
ffc1eda4: 41 82 00 70 beq- ffc1ee14 <realloc+0x138>
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
ffc1eda8: 80 01 00 08 lwz r0,8(r1)
ffc1edac: 7f a5 eb 78 mr r5,r29
ffc1edb0: 7f 9d 00 40 cmplw cr7,r29,r0
ffc1edb4: 41 9d 00 88 bgt- cr7,ffc1ee3c <realloc+0x160> <== ALWAYS TAKEN
ffc1edb8: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc1edbc: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc1edc0: 4b ff 5d 09 bl ffc14ac8 <memcpy> <== NOT EXECUTED
free( ptr );
ffc1edc4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1edc8: 4b fe 63 d5 bl ffc0519c <free> <== NOT EXECUTED
return new_area;
ffc1edcc: 7f 9f e3 78 mr r31,r28 <== NOT EXECUTED
}
ffc1edd0: 80 01 00 2c lwz r0,44(r1)
ffc1edd4: 7f e3 fb 78 mr r3,r31
ffc1edd8: 83 81 00 18 lwz r28,24(r1)
ffc1eddc: 7c 08 03 a6 mtlr r0
ffc1ede0: 83 a1 00 1c lwz r29,28(r1)
ffc1ede4: 83 c1 00 20 lwz r30,32(r1)
ffc1ede8: 83 e1 00 24 lwz r31,36(r1)
ffc1edec: 38 21 00 28 addi r1,r1,40
ffc1edf0: 4e 80 00 20 blr
* This routine returns true if thread dispatch indicates
* that we are in a critical section.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Dispatch_in_critical_section(void)
{
if ( _Thread_Dispatch_disable_level == 0 )
ffc1edf4: 3d 20 00 00 lis r9,0
ffc1edf8: 80 09 28 0c lwz r0,10252(r9)
ffc1edfc: 2f 80 00 00 cmpwi cr7,r0,0
ffc1ee00: 40 9e 00 14 bne- cr7,ffc1ee14 <realloc+0x138> <== NEVER TAKEN
if (_System_state_Is_up(_System_state_Get())) {
if (_Thread_Dispatch_in_critical_section())
return (void *) 0;
if (_ISR_Nest_level > 0)
ffc1ee04: 3d 20 00 00 lis r9,0
ffc1ee08: 80 09 31 4c lwz r0,12620(r9)
ffc1ee0c: 2f 80 00 00 cmpwi cr7,r0,0
ffc1ee10: 41 9e ff 14 beq+ cr7,ffc1ed24 <realloc+0x48> <== ALWAYS TAKEN
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
ffc1ee14: 80 01 00 2c lwz r0,44(r1)
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
return (void *) 0;
ffc1ee18: 3b e0 00 00 li r31,0
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
ffc1ee1c: 7f e3 fb 78 mr r3,r31
ffc1ee20: 83 81 00 18 lwz r28,24(r1)
ffc1ee24: 7c 08 03 a6 mtlr r0
ffc1ee28: 83 a1 00 1c lwz r29,28(r1)
ffc1ee2c: 83 c1 00 20 lwz r30,32(r1)
ffc1ee30: 83 e1 00 24 lwz r31,36(r1)
ffc1ee34: 38 21 00 28 addi r1,r1,40
ffc1ee38: 4e 80 00 20 blr
if ( !new_area ) {
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
ffc1ee3c: 7f e4 fb 78 mr r4,r31
ffc1ee40: 7c 05 03 78 mr r5,r0
ffc1ee44: 7f 83 e3 78 mr r3,r28
ffc1ee48: 4b ff 5c 81 bl ffc14ac8 <memcpy>
free( ptr );
ffc1ee4c: 7f e3 fb 78 mr r3,r31
ffc1ee50: 4b fe 63 4d bl ffc0519c <free>
return new_area;
ffc1ee54: 7f 9f e3 78 mr r31,r28
ffc1ee58: 4b ff ff 78 b ffc1edd0 <realloc+0xf4>
*/
if ( !ptr )
return malloc( size );
if ( !size ) {
free( ptr );
ffc1ee5c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1ee60: 4b fe 63 3d bl ffc0519c <free> <== NOT EXECUTED
return (void *) 0;
ffc1ee64: 3b e0 00 00 li r31,0 <== NOT EXECUTED
ffc1ee68: 4b ff ff 00 b ffc1ed68 <realloc+0x8c> <== NOT EXECUTED
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
errno = EINVAL;
ffc1ee6c: 4b ff 4f 21 bl ffc13d8c <__errno>
ffc1ee70: 38 00 00 16 li r0,22
ffc1ee74: 90 03 00 00 stw r0,0(r3)
return (void *) 0;
ffc1ee78: 3b e0 00 00 li r31,0
ffc1ee7c: 4b ff fe ec b ffc1ed68 <realloc+0x8c>
/*
* Continue with realloc().
*/
if ( !ptr )
return malloc( size );
ffc1ee80: 7f a3 eb 78 mr r3,r29
ffc1ee84: 4b fe 67 35 bl ffc055b8 <malloc>
ffc1ee88: 7c 7f 1b 78 mr r31,r3
ffc1ee8c: 4b ff fe dc b ffc1ed68 <realloc+0x8c>
ffc06378 <rmdir>:
#include <rtems/seterr.h>
int rmdir(
const char *pathname
)
{
ffc06378: 94 21 ff b0 stwu r1,-80(r1)
ffc0637c: 7c 08 02 a6 mflr r0
ffc06380: 93 a1 00 44 stw r29,68(r1)
ffc06384: 93 c1 00 48 stw r30,72(r1)
*/
parentpathlen = rtems_filesystem_dirname ( pathname );
if ( parentpathlen == 0 )
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
ffc06388: 3b c1 00 20 addi r30,r1,32
#include <rtems/seterr.h>
int rmdir(
const char *pathname
)
{
ffc0638c: 93 e1 00 4c stw r31,76(r1)
ffc06390: 7c 7f 1b 78 mr r31,r3
ffc06394: 90 01 00 54 stw r0,84(r1)
ffc06398: 93 61 00 3c stw r27,60(r1)
ffc0639c: 93 81 00 40 stw r28,64(r1)
/*
* Get the parent node of the node we wish to remove. Find the parent path.
*/
parentpathlen = rtems_filesystem_dirname ( pathname );
ffc063a0: 4b ff ec f1 bl ffc05090 <rtems_filesystem_dirname>
if ( parentpathlen == 0 )
ffc063a4: 7c 7d 1b 79 mr. r29,r3
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
ffc063a8: 7f e3 fb 78 mr r3,r31
* Get the parent node of the node we wish to remove. Find the parent path.
*/
parentpathlen = rtems_filesystem_dirname ( pathname );
if ( parentpathlen == 0 )
ffc063ac: 40 82 00 b8 bne- ffc06464 <rmdir+0xec>
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
ffc063b0: 38 81 00 08 addi r4,r1,8
ffc063b4: 7f c5 f3 78 mr r5,r30
ffc063b8: 48 00 01 79 bl ffc06530 <rtems_filesystem_get_start_loc>
ffc063bc: 3b a0 00 00 li r29,0
const char *name;
rtems_filesystem_location_info_t parentloc;
rtems_filesystem_location_info_t loc;
int i;
int result;
bool free_parentloc = false;
ffc063c0: 3b 80 00 00 li r28,0
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
ffc063c4: 80 01 00 20 lwz r0,32(r1)
name = pathname + parentpathlen;
ffc063c8: 7f ff ea 14 add r31,r31,r29
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
ffc063cc: 7f e3 fb 78 mr r3,r31
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
ffc063d0: 90 01 00 0c stw r0,12(r1)
ffc063d4: 80 01 00 24 lwz r0,36(r1)
ffc063d8: 90 01 00 10 stw r0,16(r1)
ffc063dc: 80 01 00 28 lwz r0,40(r1)
ffc063e0: 90 01 00 14 stw r0,20(r1)
ffc063e4: 80 01 00 2c lwz r0,44(r1)
ffc063e8: 90 01 00 18 stw r0,24(r1)
ffc063ec: 80 01 00 30 lwz r0,48(r1)
ffc063f0: 90 01 00 1c stw r0,28(r1)
name = pathname + parentpathlen;
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
ffc063f4: 48 00 ef 95 bl ffc15388 <strlen>
ffc063f8: 7c 64 1b 78 mr r4,r3
ffc063fc: 7f e3 fb 78 mr r3,r31
ffc06400: 4b ff ec f1 bl ffc050f0 <rtems_filesystem_prefix_separators>
ffc06404: 7f ff 1a 14 add r31,r31,r3
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
ffc06408: 7f e3 fb 78 mr r3,r31
ffc0640c: 48 00 ef 7d bl ffc15388 <strlen>
ffc06410: 38 a0 00 00 li r5,0
ffc06414: 7c 64 1b 78 mr r4,r3
ffc06418: 38 c1 00 0c addi r6,r1,12
ffc0641c: 7f e3 fb 78 mr r3,r31
ffc06420: 38 e0 00 00 li r7,0
ffc06424: 4b ff eb 45 bl ffc04f68 <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
ffc06428: 2f 83 00 00 cmpwi cr7,r3,0
ffc0642c: 41 9e 00 60 beq- cr7,ffc0648c <rmdir+0x114>
if ( free_parentloc )
ffc06430: 2f 9c 00 00 cmpwi cr7,r28,0
rtems_filesystem_freenode( &parentloc );
return -1;
ffc06434: 3b 60 ff ff li r27,-1
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 )
ffc06438: 40 9e 00 9c bne- cr7,ffc064d4 <rmdir+0x15c>
rtems_filesystem_freenode( &loc );
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return result;
}
ffc0643c: 80 01 00 54 lwz r0,84(r1)
ffc06440: 7f 63 db 78 mr r3,r27
ffc06444: 83 81 00 40 lwz r28,64(r1)
ffc06448: 7c 08 03 a6 mtlr r0
ffc0644c: 83 61 00 3c lwz r27,60(r1)
ffc06450: 83 a1 00 44 lwz r29,68(r1)
ffc06454: 83 c1 00 48 lwz r30,72(r1)
ffc06458: 83 e1 00 4c lwz r31,76(r1)
ffc0645c: 38 21 00 50 addi r1,r1,80
ffc06460: 4e 80 00 20 blr
parentpathlen = rtems_filesystem_dirname ( pathname );
if ( parentpathlen == 0 )
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
else {
result = rtems_filesystem_evaluate_path(pathname, parentpathlen,
ffc06464: 7f a4 eb 78 mr r4,r29
ffc06468: 38 a0 00 02 li r5,2
ffc0646c: 7f c6 f3 78 mr r6,r30
ffc06470: 38 e0 00 00 li r7,0
ffc06474: 4b ff eb a1 bl ffc05014 <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
return -1;
ffc06478: 3b 60 ff ff li r27,-1
else {
result = rtems_filesystem_evaluate_path(pathname, parentpathlen,
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
ffc0647c: 2f 83 00 00 cmpwi cr7,r3,0
ffc06480: 40 be ff bc bne- cr7,ffc0643c <rmdir+0xc4> <== NEVER TAKEN
return -1;
free_parentloc = true;
ffc06484: 3b 80 00 01 li r28,1
ffc06488: 4b ff ff 3c b ffc063c4 <rmdir+0x4c>
}
/*
* Verify you can remove this node as a directory.
*/
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
ffc0648c: 81 21 00 18 lwz r9,24(r1)
ffc06490: 38 61 00 0c addi r3,r1,12
ffc06494: 80 09 00 10 lwz r0,16(r9)
ffc06498: 7c 09 03 a6 mtctr r0
ffc0649c: 4e 80 04 21 bctrl
ffc064a0: 2f 83 00 01 cmpwi cr7,r3,1
ffc064a4: 40 9e 00 60 bne- cr7,ffc06504 <rmdir+0x18c>
/*
* Use the filesystems rmnod to remove the node.
*/
result = (*loc.handlers->rmnod_h)( &parentloc, &loc );
ffc064a8: 81 21 00 14 lwz r9,20(r1)
ffc064ac: 38 81 00 0c addi r4,r1,12
ffc064b0: 7f c3 f3 78 mr r3,r30
ffc064b4: 80 09 00 34 lwz r0,52(r9)
ffc064b8: 7c 09 03 a6 mtctr r0
ffc064bc: 4e 80 04 21 bctrl
ffc064c0: 7c 7b 1b 78 mr r27,r3
rtems_filesystem_freenode( &loc );
ffc064c4: 38 61 00 0c addi r3,r1,12
ffc064c8: 4b ff ec a9 bl ffc05170 <rtems_filesystem_freenode>
if ( free_parentloc )
ffc064cc: 2f 9c 00 00 cmpwi cr7,r28,0
ffc064d0: 41 9e ff 6c beq+ cr7,ffc0643c <rmdir+0xc4>
rtems_filesystem_freenode( &parentloc );
ffc064d4: 7f c3 f3 78 mr r3,r30
ffc064d8: 4b ff ec 99 bl ffc05170 <rtems_filesystem_freenode>
return result;
}
ffc064dc: 80 01 00 54 lwz r0,84(r1)
ffc064e0: 7f 63 db 78 mr r3,r27
ffc064e4: 83 81 00 40 lwz r28,64(r1)
ffc064e8: 7c 08 03 a6 mtlr r0
ffc064ec: 83 61 00 3c lwz r27,60(r1)
ffc064f0: 83 a1 00 44 lwz r29,68(r1)
ffc064f4: 83 c1 00 48 lwz r30,72(r1)
ffc064f8: 83 e1 00 4c lwz r31,76(r1)
ffc064fc: 38 21 00 50 addi r1,r1,80
ffc06500: 4e 80 00 20 blr
/*
* Verify you can remove this node as a directory.
*/
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
rtems_filesystem_freenode( &loc );
ffc06504: 38 61 00 0c addi r3,r1,12
ffc06508: 4b ff ec 69 bl ffc05170 <rtems_filesystem_freenode>
if ( free_parentloc )
ffc0650c: 2f 9c 00 00 cmpwi cr7,r28,0
ffc06510: 41 be 00 0c beq+ cr7,ffc0651c <rmdir+0x1a4> <== NEVER TAKEN
rtems_filesystem_freenode( &parentloc );
ffc06514: 7f c3 f3 78 mr r3,r30
ffc06518: 4b ff ec 59 bl ffc05170 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( ENOTDIR );
ffc0651c: 48 00 dc f1 bl ffc1420c <__errno>
ffc06520: 38 00 00 14 li r0,20
ffc06524: 90 03 00 00 stw r0,0(r3)
ffc06528: 3b 60 ff ff li r27,-1
ffc0652c: 4b ff ff 10 b ffc0643c <rmdir+0xc4>
ffc0a2e8 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
ffc0a2e8: 94 21 ff b0 stwu r1,-80(r1)
ffc0a2ec: 7c 08 02 a6 mflr r0
ffc0a2f0: 93 e1 00 4c stw r31,76(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);
ffc0a2f4: 3f e0 00 00 lis r31,0
ffc0a2f8: 3b ff 2c 70 addi r31,r31,11376
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
ffc0a2fc: 93 a1 00 44 stw r29,68(r1)
ffc0a300: 7c 7d 1b 78 mr r29,r3
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);
ffc0a304: 7f e3 fb 78 mr r3,r31
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
ffc0a308: 93 c1 00 48 stw r30,72(r1)
ffc0a30c: 90 01 00 54 stw r0,84(r1)
ffc0a310: 93 61 00 3c stw r27,60(r1)
ffc0a314: 93 81 00 40 stw r28,64(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);
ffc0a318: 48 00 0c 0d bl ffc0af24 <pthread_mutex_lock>
if (result != 0) {
ffc0a31c: 7c 7e 1b 79 mr. r30,r3
ffc0a320: 40 82 00 d4 bne- ffc0a3f4 <rtems_aio_enqueue+0x10c> <== NEVER TAKEN
return result;
}
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
ffc0a324: 48 00 17 61 bl ffc0ba84 <pthread_self>
ffc0a328: 38 81 00 08 addi r4,r1,8
ffc0a32c: 38 a1 00 10 addi r5,r1,16
ffc0a330: 48 00 11 91 bl ffc0b4c0 <pthread_getschedparam>
req->caller_thread = pthread_self ();
ffc0a334: 48 00 17 51 bl ffc0ba84 <pthread_self>
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
req->policy = policy;
req->aiocbp->error_code = EINPROGRESS;
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
ffc0a338: 80 1f 00 68 lwz r0,104(r31)
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
req->caller_thread = pthread_self ();
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
ffc0a33c: 81 3d 00 14 lwz r9,20(r29)
req->policy = policy;
req->aiocbp->error_code = EINPROGRESS;
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
ffc0a340: 2f 80 00 00 cmpwi cr7,r0,0
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
req->caller_thread = pthread_self ();
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
ffc0a344: 81 61 00 10 lwz r11,16(r1)
ffc0a348: 80 09 00 18 lwz r0,24(r9)
/* _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 ();
ffc0a34c: 90 7d 00 10 stw r3,16(r29)
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
ffc0a350: 7c 00 58 50 subf r0,r0,r11
ffc0a354: 90 1d 00 0c stw r0,12(r29)
req->policy = policy;
ffc0a358: 80 01 00 08 lwz r0,8(r1)
ffc0a35c: 90 1d 00 08 stw r0,8(r29)
req->aiocbp->error_code = EINPROGRESS;
ffc0a360: 38 00 00 77 li r0,119
ffc0a364: 90 09 00 34 stw r0,52(r9)
req->aiocbp->return_value = 0;
ffc0a368: 93 c9 00 38 stw r30,56(r9)
if ((aio_request_queue.idle_threads == 0) &&
ffc0a36c: 40 9e 00 10 bne- cr7,ffc0a37c <rtems_aio_enqueue+0x94> <== NEVER TAKEN
ffc0a370: 80 1f 00 64 lwz r0,100(r31)
ffc0a374: 2f 80 00 04 cmpwi cr7,r0,4
ffc0a378: 40 9d 00 ac ble- cr7,ffc0a424 <rtems_aio_enqueue+0x13c>
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,
ffc0a37c: 3f 60 00 00 lis r27,0
ffc0a380: 80 89 00 00 lwz r4,0(r9)
ffc0a384: 3b 7b 2c b8 addi r27,r27,11448
ffc0a388: 7f 63 db 78 mr r3,r27
ffc0a38c: 38 a0 00 00 li r5,0
ffc0a390: 4b ff f9 49 bl ffc09cd8 <rtems_aio_search_fd>
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
ffc0a394: 7c 7c 1b 79 mr. r28,r3
ffc0a398: 41 82 01 04 beq- ffc0a49c <rtems_aio_enqueue+0x1b4>
{
pthread_mutex_lock (&r_chain->mutex);
ffc0a39c: 3b 7c 00 1c addi r27,r28,28
ffc0a3a0: 7f 63 db 78 mr r3,r27
ffc0a3a4: 48 00 0b 81 bl ffc0af24 <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
ffc0a3a8: 38 7c 00 08 addi r3,r28,8
ffc0a3ac: 7f a4 eb 78 mr r4,r29
ffc0a3b0: 4b ff fd a9 bl ffc0a158 <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
ffc0a3b4: 38 7c 00 20 addi r3,r28,32
ffc0a3b8: 48 00 05 6d bl ffc0a924 <pthread_cond_signal>
pthread_mutex_unlock (&r_chain->mutex);
ffc0a3bc: 7f 63 db 78 mr r3,r27
ffc0a3c0: 48 00 0c 31 bl ffc0aff0 <pthread_mutex_unlock>
if (aio_request_queue.idle_threads > 0)
pthread_cond_signal (&aio_request_queue.new_req);
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
ffc0a3c4: 7f e3 fb 78 mr r3,r31
ffc0a3c8: 48 00 0c 29 bl ffc0aff0 <pthread_mutex_unlock>
return 0;
}
ffc0a3cc: 80 01 00 54 lwz r0,84(r1)
ffc0a3d0: 7f c3 f3 78 mr r3,r30
ffc0a3d4: 83 61 00 3c lwz r27,60(r1)
ffc0a3d8: 7c 08 03 a6 mtlr r0
ffc0a3dc: 83 81 00 40 lwz r28,64(r1)
ffc0a3e0: 83 a1 00 44 lwz r29,68(r1)
ffc0a3e4: 83 c1 00 48 lwz r30,72(r1)
ffc0a3e8: 83 e1 00 4c lwz r31,76(r1)
ffc0a3ec: 38 21 00 50 addi r1,r1,80
ffc0a3f0: 4e 80 00 20 blr
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
if (result != 0) {
free (req);
ffc0a3f4: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc0a3f8: 4b ff b6 19 bl ffc05a10 <free> <== NOT EXECUTED
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
return 0;
}
ffc0a3fc: 80 01 00 54 lwz r0,84(r1) <== NOT EXECUTED
ffc0a400: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc0a404: 83 61 00 3c lwz r27,60(r1) <== NOT EXECUTED
ffc0a408: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc0a40c: 83 81 00 40 lwz r28,64(r1) <== NOT EXECUTED
ffc0a410: 83 a1 00 44 lwz r29,68(r1) <== NOT EXECUTED
ffc0a414: 83 c1 00 48 lwz r30,72(r1) <== NOT EXECUTED
ffc0a418: 83 e1 00 4c lwz r31,76(r1) <== NOT EXECUTED
ffc0a41c: 38 21 00 50 addi r1,r1,80 <== NOT EXECUTED
ffc0a420: 4e 80 00 20 blr <== NOT EXECUTED
if ((aio_request_queue.idle_threads == 0) &&
aio_request_queue.active_threads < AIO_MAX_THREADS)
/* we still have empty places on the active_threads chain */
{
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
ffc0a424: 80 89 00 00 lwz r4,0(r9)
ffc0a428: 38 7f 00 48 addi r3,r31,72
ffc0a42c: 38 a0 00 01 li r5,1
ffc0a430: 4b ff f8 a9 bl ffc09cd8 <rtems_aio_search_fd>
if (r_chain->new_fd == 1) {
ffc0a434: 80 03 00 18 lwz r0,24(r3)
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);
ffc0a438: 7c 7c 1b 78 mr r28,r3
if (r_chain->new_fd == 1) {
ffc0a43c: 2f 80 00 01 cmpwi cr7,r0,1
ffc0a440: 40 9e ff 5c bne+ cr7,ffc0a39c <rtems_aio_enqueue+0xb4>
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
ffc0a444: 7f a4 eb 78 mr r4,r29
ffc0a448: 38 63 00 08 addi r3,r3,8
ffc0a44c: 48 00 2d a9 bl ffc0d1f4 <_Chain_Insert>
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
ffc0a450: 93 dc 00 18 stw r30,24(r28)
pthread_mutex_init (&r_chain->mutex, NULL);
ffc0a454: 38 80 00 00 li r4,0
ffc0a458: 38 7c 00 1c addi r3,r28,28
ffc0a45c: 48 00 09 41 bl ffc0ad9c <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
ffc0a460: 38 80 00 00 li r4,0
ffc0a464: 38 7c 00 20 addi r3,r28,32
ffc0a468: 48 00 03 c9 bl ffc0a830 <pthread_cond_init>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
ffc0a46c: 3c a0 ff c1 lis r5,-63
ffc0a470: 38 61 00 0c addi r3,r1,12
ffc0a474: 38 9f 00 08 addi r4,r31,8
ffc0a478: 38 a5 9e a4 addi r5,r5,-24924
ffc0a47c: 7f 86 e3 78 mr r6,r28
ffc0a480: 48 00 0d 29 bl ffc0b1a8 <pthread_create>
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
ffc0a484: 7c 7d 1b 79 mr. r29,r3
ffc0a488: 40 82 00 80 bne- ffc0a508 <rtems_aio_enqueue+0x220> <== NEVER TAKEN
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
++aio_request_queue.active_threads;
ffc0a48c: 81 3f 00 64 lwz r9,100(r31)
ffc0a490: 38 09 00 01 addi r0,r9,1
ffc0a494: 90 1f 00 64 stw r0,100(r31)
ffc0a498: 4b ff ff 2c b ffc0a3c4 <rtems_aio_enqueue+0xdc>
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
ffc0a49c: 81 3d 00 14 lwz r9,20(r29)
ffc0a4a0: 38 7b 00 0c addi r3,r27,12
ffc0a4a4: 38 a0 00 01 li r5,1
ffc0a4a8: 80 89 00 00 lwz r4,0(r9)
ffc0a4ac: 4b ff f8 2d bl ffc09cd8 <rtems_aio_search_fd>
ffc0a4b0: 7f a4 eb 78 mr r4,r29
if (r_chain->new_fd == 1) {
ffc0a4b4: 80 03 00 18 lwz r0,24(r3)
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
ffc0a4b8: 7c 7b 1b 78 mr r27,r3
ffc0a4bc: 38 63 00 08 addi r3,r3,8
if (r_chain->new_fd == 1) {
ffc0a4c0: 2f 80 00 01 cmpwi cr7,r0,1
ffc0a4c4: 41 9e 00 20 beq- cr7,ffc0a4e4 <rtems_aio_enqueue+0x1fc>
r_chain->new_fd = 0;
pthread_mutex_init (&r_chain->mutex, NULL);
pthread_cond_init (&r_chain->cond, NULL);
} else
/* just insert the request in the existing fd chain */
rtems_aio_insert_prio (&r_chain->perfd, req);
ffc0a4c8: 4b ff fc 91 bl ffc0a158 <rtems_aio_insert_prio>
if (aio_request_queue.idle_threads > 0)
ffc0a4cc: 80 1f 00 68 lwz r0,104(r31)
ffc0a4d0: 2f 80 00 00 cmpwi cr7,r0,0
ffc0a4d4: 40 bd fe f0 ble- cr7,ffc0a3c4 <rtems_aio_enqueue+0xdc> <== ALWAYS TAKEN
pthread_cond_signal (&aio_request_queue.new_req);
ffc0a4d8: 38 7f 00 04 addi r3,r31,4 <== NOT EXECUTED
ffc0a4dc: 48 00 04 49 bl ffc0a924 <pthread_cond_signal> <== NOT EXECUTED
ffc0a4e0: 4b ff fe e4 b ffc0a3c4 <rtems_aio_enqueue+0xdc> <== NOT EXECUTED
ffc0a4e4: 48 00 2d 11 bl ffc0d1f4 <_Chain_Insert>
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;
ffc0a4e8: 93 9b 00 18 stw r28,24(r27)
pthread_mutex_init (&r_chain->mutex, NULL);
ffc0a4ec: 38 7b 00 1c addi r3,r27,28
ffc0a4f0: 38 80 00 00 li r4,0
ffc0a4f4: 48 00 08 a9 bl ffc0ad9c <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
ffc0a4f8: 38 7b 00 20 addi r3,r27,32
ffc0a4fc: 38 80 00 00 li r4,0
ffc0a500: 48 00 03 31 bl ffc0a830 <pthread_cond_init>
ffc0a504: 4b ff ff c8 b ffc0a4cc <rtems_aio_enqueue+0x1e4>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
pthread_mutex_unlock (&aio_request_queue.mutex);
ffc0a508: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc0a50c: 48 00 0a e5 bl ffc0aff0 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
ffc0a510: 7f be eb 78 mr r30,r29 <== NOT EXECUTED
ffc0a514: 4b ff fe b8 b ffc0a3cc <rtems_aio_enqueue+0xe4> <== NOT EXECUTED
ffc09ea4 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
ffc09ea4: 94 21 ff a0 stwu r1,-96(r1)
ffc09ea8: 7c 08 02 a6 mflr r0
ffc09eac: 93 41 00 48 stw r26,72(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);
ffc09eb0: 3f 40 00 00 lis r26,0
ffc09eb4: 3b 5a 2c 70 addi r26,r26,11376
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
ffc09eb8: 90 01 00 64 stw r0,100(r1)
ffc09ebc: 92 c1 00 38 stw r22,56(r1)
ffc09ec0: 93 e1 00 5c stw r31,92(r1)
ffc09ec4: 92 e1 00 3c stw r23,60(r1)
--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,
ffc09ec8: 3a fa 00 04 addi r23,r26,4
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
ffc09ecc: 93 01 00 40 stw r24,64(r1)
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)) {
ffc09ed0: 3b 1a 00 58 addi r24,r26,88
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
ffc09ed4: 93 21 00 44 stw r25,68(r1)
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
ffc09ed8: 3b 20 ff ff li r25,-1
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
ffc09edc: 93 61 00 4c stw r27,76(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);
ffc09ee0: 7f 5b d3 78 mr r27,r26
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
ffc09ee4: 93 81 00 50 stw r28,80(r1)
if (result == -1) {
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
} else {
req->aiocbp->return_value = result;
req->aiocbp->error_code = 0;
ffc09ee8: 3b 80 00 00 li r28,0
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
ffc09eec: 93 a1 00 54 stw r29,84(r1)
ffc09ef0: 3b a3 00 1c addi r29,r3,28
ffc09ef4: 93 c1 00 58 stw r30,88(r1)
ffc09ef8: 7c 7e 1b 78 mr r30,r3
/* 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);
ffc09efc: 7f a3 eb 78 mr r3,r29
ffc09f00: 48 00 10 25 bl ffc0af24 <pthread_mutex_lock>
if (result != 0)
ffc09f04: 7c 76 1b 79 mr. r22,r3
ffc09f08: 40 82 00 8c bne- ffc09f94 <rtems_aio_handle+0xf0> <== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
ffc09f0c: 83 fe 00 08 lwz r31,8(r30)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
ffc09f10: 38 1e 00 0c addi r0,r30,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)) {
ffc09f14: 7f 9f 00 00 cmpw cr7,r31,r0
ffc09f18: 41 9e 01 10 beq- cr7,ffc0a028 <rtems_aio_handle+0x184>
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);
ffc09f1c: 48 00 1b 69 bl ffc0ba84 <pthread_self>
ffc09f20: 38 81 00 08 addi r4,r1,8
ffc09f24: 38 a1 00 14 addi r5,r1,20
ffc09f28: 48 00 15 99 bl ffc0b4c0 <pthread_getschedparam>
param.sched_priority = req->priority;
ffc09f2c: 80 1f 00 0c lwz r0,12(r31)
ffc09f30: 90 01 00 14 stw r0,20(r1)
pthread_setschedparam (pthread_self(), req->policy, ¶m);
ffc09f34: 48 00 1b 51 bl ffc0ba84 <pthread_self>
ffc09f38: 38 a1 00 14 addi r5,r1,20
ffc09f3c: 80 9f 00 08 lwz r4,8(r31)
ffc09f40: 48 00 1b 55 bl ffc0ba94 <pthread_setschedparam>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
ffc09f44: 7f e3 fb 78 mr r3,r31
ffc09f48: 48 00 32 45 bl ffc0d18c <_Chain_Extract>
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
ffc09f4c: 7f a3 eb 78 mr r3,r29
ffc09f50: 48 00 10 a1 bl ffc0aff0 <pthread_mutex_unlock>
switch (req->aiocbp->aio_lio_opcode) {
ffc09f54: 82 df 00 14 lwz r22,20(r31)
ffc09f58: 80 16 00 30 lwz r0,48(r22)
ffc09f5c: 2f 80 00 02 cmpwi cr7,r0,2
ffc09f60: 41 9e 00 ac beq- cr7,ffc0a00c <rtems_aio_handle+0x168>
ffc09f64: 2f 80 00 03 cmpwi cr7,r0,3
ffc09f68: 41 9e 00 98 beq- cr7,ffc0a000 <rtems_aio_handle+0x15c> <== NEVER TAKEN
ffc09f6c: 2f 80 00 01 cmpwi cr7,r0,1
ffc09f70: 41 9e 00 60 beq- cr7,ffc09fd0 <rtems_aio_handle+0x12c> <== ALWAYS TAKEN
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
ffc09f74: 93 36 00 38 stw r25,56(r22) <== NOT EXECUTED
req->aiocbp->error_code = errno;
ffc09f78: 48 00 cd 51 bl ffc16cc8 <__errno> <== NOT EXECUTED
ffc09f7c: 80 03 00 00 lwz r0,0(r3) <== NOT EXECUTED
/* acquire the mutex of the current fd chain.
we don't need to lock the queue mutex since we can
add requests to idle fd chains or even active ones
if the working request has been extracted from the
chain */
result = pthread_mutex_lock (&r_chain->mutex);
ffc09f80: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
ffc09f84: 90 16 00 34 stw r0,52(r22) <== NOT EXECUTED
/* acquire the mutex of the current fd chain.
we don't need to lock the queue mutex since we can
add requests to idle fd chains or even active ones
if the working request has been extracted from the
chain */
result = pthread_mutex_lock (&r_chain->mutex);
ffc09f88: 48 00 0f 9d bl ffc0af24 <pthread_mutex_lock> <== NOT EXECUTED
if (result != 0)
ffc09f8c: 7c 76 1b 79 mr. r22,r3 <== NOT EXECUTED
ffc09f90: 41 82 ff 7c beq+ ffc09f0c <rtems_aio_handle+0x68> <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
ffc09f94: 80 01 00 64 lwz r0,100(r1)
ffc09f98: 38 60 00 00 li r3,0
ffc09f9c: 82 c1 00 38 lwz r22,56(r1)
ffc09fa0: 7c 08 03 a6 mtlr r0
ffc09fa4: 82 e1 00 3c lwz r23,60(r1)
ffc09fa8: 83 01 00 40 lwz r24,64(r1)
ffc09fac: 83 21 00 44 lwz r25,68(r1)
ffc09fb0: 83 41 00 48 lwz r26,72(r1)
ffc09fb4: 83 61 00 4c lwz r27,76(r1)
ffc09fb8: 83 81 00 50 lwz r28,80(r1)
ffc09fbc: 83 a1 00 54 lwz r29,84(r1)
ffc09fc0: 83 c1 00 58 lwz r30,88(r1)
ffc09fc4: 83 e1 00 5c lwz r31,92(r1)
ffc09fc8: 38 21 00 60 addi r1,r1,96
ffc09fcc: 4e 80 00 20 blr
pthread_mutex_unlock (&r_chain->mutex);
switch (req->aiocbp->aio_lio_opcode) {
case LIO_READ:
AIO_printf ("read\n");
result = pread (req->aiocbp->aio_fildes,
ffc09fd0: 80 76 00 00 lwz r3,0(r22)
ffc09fd4: 80 96 00 10 lwz r4,16(r22)
ffc09fd8: 80 b6 00 14 lwz r5,20(r22)
ffc09fdc: 80 f6 00 08 lwz r7,8(r22)
ffc09fe0: 81 16 00 0c lwz r8,12(r22)
ffc09fe4: 48 00 dc 19 bl ffc17bfc <pread>
break;
default:
result = -1;
}
if (result == -1) {
ffc09fe8: 2f 83 ff ff cmpwi cr7,r3,-1
ffc09fec: 41 9e 01 4c beq- cr7,ffc0a138 <rtems_aio_handle+0x294> <== NEVER TAKEN
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
} else {
req->aiocbp->return_value = result;
ffc09ff0: 81 3f 00 14 lwz r9,20(r31)
ffc09ff4: 90 69 00 38 stw r3,56(r9)
req->aiocbp->error_code = 0;
ffc09ff8: 93 89 00 34 stw r28,52(r9)
ffc09ffc: 4b ff ff 00 b ffc09efc <rtems_aio_handle+0x58>
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_SYNC:
AIO_printf ("sync\n");
result = fsync (req->aiocbp->aio_fildes);
ffc0a000: 80 76 00 00 lwz r3,0(r22) <== NOT EXECUTED
ffc0a004: 48 00 8b 09 bl ffc12b0c <fsync> <== NOT EXECUTED
break;
ffc0a008: 4b ff ff e0 b ffc09fe8 <rtems_aio_handle+0x144> <== NOT EXECUTED
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_WRITE:
AIO_printf ("write\n");
result = pwrite (req->aiocbp->aio_fildes,
ffc0a00c: 80 76 00 00 lwz r3,0(r22)
ffc0a010: 80 96 00 10 lwz r4,16(r22)
ffc0a014: 80 b6 00 14 lwz r5,20(r22)
ffc0a018: 80 f6 00 08 lwz r7,8(r22)
ffc0a01c: 81 16 00 0c lwz r8,12(r22)
ffc0a020: 48 00 dd 19 bl ffc17d38 <pwrite>
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
ffc0a024: 4b ff ff c4 b ffc09fe8 <rtems_aio_handle+0x144>
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
ffc0a028: 7f a3 eb 78 mr r3,r29
ffc0a02c: 48 00 0f c5 bl ffc0aff0 <pthread_mutex_unlock>
pthread_mutex_lock (&aio_request_queue.mutex);
ffc0a030: 7f 63 db 78 mr r3,r27
ffc0a034: 48 00 0e f1 bl ffc0af24 <pthread_mutex_lock>
if (rtems_chain_is_empty (chain))
ffc0a038: 80 1e 00 08 lwz r0,8(r30)
ffc0a03c: 7f 9f 00 00 cmpw cr7,r31,r0
ffc0a040: 41 9e 00 10 beq- cr7,ffc0a050 <rtems_aio_handle+0x1ac> <== ALWAYS TAKEN
}
}
/* 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);
ffc0a044: 7f 63 db 78 mr r3,r27
ffc0a048: 48 00 0f a9 bl ffc0aff0 <pthread_mutex_unlock>
ffc0a04c: 4b ff fe b0 b ffc09efc <rtems_aio_handle+0x58>
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
ffc0a050: 38 81 00 0c addi r4,r1,12
ffc0a054: 38 60 00 01 li r3,1
ffc0a058: 48 00 06 29 bl ffc0a680 <clock_gettime>
timeout.tv_sec += 3;
ffc0a05c: 81 21 00 0c lwz r9,12(r1)
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
ffc0a060: 3b fe 00 20 addi r31,r30,32
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
timeout.tv_nsec = 0;
ffc0a064: 92 c1 00 10 stw r22,16(r1)
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
ffc0a068: 38 09 00 03 addi r0,r9,3
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
ffc0a06c: 7f e3 fb 78 mr r3,r31
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
ffc0a070: 90 01 00 0c stw r0,12(r1)
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
ffc0a074: 7f 64 db 78 mr r4,r27
ffc0a078: 38 a1 00 0c addi r5,r1,12
ffc0a07c: 48 00 09 85 bl ffc0aa00 <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) {
ffc0a080: 2f 83 00 74 cmpwi cr7,r3,116
ffc0a084: 40 9e ff c0 bne+ cr7,ffc0a044 <rtems_aio_handle+0x1a0> <== NEVER TAKEN
ffc0a088: 7f c3 f3 78 mr r3,r30
ffc0a08c: 48 00 31 01 bl ffc0d18c <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd);
pthread_mutex_destroy (&r_chain->mutex);
ffc0a090: 7f a3 eb 78 mr r3,r29
ffc0a094: 48 00 0b 45 bl ffc0abd8 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->cond);
ffc0a098: 7f e3 fb 78 mr r3,r31
ffc0a09c: 48 00 06 85 bl ffc0a720 <pthread_cond_destroy>
free (r_chain);
ffc0a0a0: 7f c3 f3 78 mr r3,r30
ffc0a0a4: 4b ff b9 6d bl ffc05a10 <free>
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
ffc0a0a8: 83 db 00 54 lwz r30,84(r27)
/* 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)) {
ffc0a0ac: 7f 9e c0 00 cmpw cr7,r30,r24
ffc0a0b0: 41 9e 00 34 beq- cr7,ffc0a0e4 <rtems_aio_handle+0x240>
}
}
/* 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;
ffc0a0b4: 81 3a 00 68 lwz r9,104(r26)
ffc0a0b8: 7f c3 f3 78 mr r3,r30
++aio_request_queue.active_threads;
ffc0a0bc: 81 7a 00 64 lwz r11,100(r26)
ffc0a0c0: 3b be 00 1c addi r29,r30,28
}
}
/* 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;
ffc0a0c4: 39 29 ff ff addi r9,r9,-1
++aio_request_queue.active_threads;
ffc0a0c8: 38 0b 00 01 addi r0,r11,1
}
}
/* 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;
ffc0a0cc: 91 3a 00 68 stw r9,104(r26)
++aio_request_queue.active_threads;
ffc0a0d0: 90 1a 00 64 stw r0,100(r26)
ffc0a0d4: 48 00 30 b9 bl ffc0d18c <_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);
ffc0a0d8: 7f c3 f3 78 mr r3,r30
ffc0a0dc: 4b ff fd 39 bl ffc09e14 <rtems_aio_move_to_work>
ffc0a0e0: 4b ff ff 64 b ffc0a044 <rtems_aio_handle+0x1a0>
/* 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;
ffc0a0e4: 81 3b 00 68 lwz r9,104(r27)
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
ffc0a0e8: 38 81 00 0c addi r4,r1,12
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;
--aio_request_queue.active_threads;
ffc0a0ec: 80 1b 00 64 lwz r0,100(r27)
clock_gettime (CLOCK_REALTIME, &timeout);
ffc0a0f0: 38 60 00 01 li r3,1
/* 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;
ffc0a0f4: 39 29 00 01 addi r9,r9,1
--aio_request_queue.active_threads;
ffc0a0f8: 30 00 ff ff addic r0,r0,-1
/* 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;
ffc0a0fc: 91 3b 00 68 stw r9,104(r27)
--aio_request_queue.active_threads;
ffc0a100: 90 1b 00 64 stw r0,100(r27)
clock_gettime (CLOCK_REALTIME, &timeout);
ffc0a104: 48 00 05 7d bl ffc0a680 <clock_gettime>
timeout.tv_sec += 3;
ffc0a108: 80 01 00 0c lwz r0,12(r1)
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
ffc0a10c: 7e e3 bb 78 mr r3,r23
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
timeout.tv_nsec = 0;
ffc0a110: 92 c1 00 10 stw r22,16(r1)
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;
ffc0a114: 30 00 00 03 addic r0,r0,3
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
ffc0a118: 7f 64 db 78 mr r4,r27
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;
ffc0a11c: 90 01 00 0c stw r0,12(r1)
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
ffc0a120: 38 a1 00 0c addi r5,r1,12
ffc0a124: 48 00 08 dd bl ffc0aa00 <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) {
ffc0a128: 2f 83 00 74 cmpwi cr7,r3,116
ffc0a12c: 41 9e 00 14 beq- cr7,ffc0a140 <rtems_aio_handle+0x29c> <== ALWAYS TAKEN
ffc0a130: 83 db 00 54 lwz r30,84(r27) <== NOT EXECUTED
ffc0a134: 4b ff ff 80 b ffc0a0b4 <rtems_aio_handle+0x210> <== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
ffc0a138: 82 df 00 14 lwz r22,20(r31) <== NOT EXECUTED
ffc0a13c: 4b ff fe 38 b ffc09f74 <rtems_aio_handle+0xd0> <== NOT EXECUTED
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
ffc0a140: 80 1b 00 68 lwz r0,104(r27)
pthread_mutex_unlock (&aio_request_queue.mutex);
ffc0a144: 7f 63 db 78 mr r3,r27
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
ffc0a148: 30 00 ff ff addic r0,r0,-1
ffc0a14c: 90 1b 00 68 stw r0,104(r27)
pthread_mutex_unlock (&aio_request_queue.mutex);
ffc0a150: 48 00 0e a1 bl ffc0aff0 <pthread_mutex_unlock>
return NULL;
ffc0a154: 4b ff fe 40 b ffc09f94 <rtems_aio_handle+0xf0>
ffc09b8c <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
ffc09b8c: 94 21 ff e8 stwu r1,-24(r1)
ffc09b90: 7c 08 02 a6 mflr r0
ffc09b94: 93 c1 00 10 stw r30,16(r1)
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
ffc09b98: 3f c0 00 00 lis r30,0
ffc09b9c: 3b de 2c 78 addi r30,r30,11384
ffc09ba0: 7f c3 f3 78 mr r3,r30
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
ffc09ba4: 93 a1 00 0c stw r29,12(r1)
ffc09ba8: 90 01 00 1c stw r0,28(r1)
ffc09bac: 93 e1 00 14 stw r31,20(r1)
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
ffc09bb0: 48 00 15 8d bl ffc0b13c <pthread_attr_init>
if (result != 0)
ffc09bb4: 7c 7d 1b 79 mr. r29,r3
ffc09bb8: 41 82 00 24 beq- ffc09bdc <rtems_aio_init+0x50> <== ALWAYS TAKEN
aio_request_queue.active_threads = 0;
aio_request_queue.idle_threads = 0;
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
return result;
}
ffc09bbc: 80 01 00 1c lwz r0,28(r1) <== NOT EXECUTED
ffc09bc0: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc09bc4: 83 c1 00 10 lwz r30,16(r1) <== NOT EXECUTED
ffc09bc8: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc09bcc: 83 a1 00 0c lwz r29,12(r1) <== NOT EXECUTED
ffc09bd0: 83 e1 00 14 lwz r31,20(r1) <== NOT EXECUTED
ffc09bd4: 38 21 00 18 addi r1,r1,24 <== NOT EXECUTED
ffc09bd8: 4e 80 00 20 blr <== NOT EXECUTED
result = pthread_attr_init (&aio_request_queue.attr);
if (result != 0)
return result;
result =
ffc09bdc: 7f c3 f3 78 mr r3,r30
ffc09be0: 38 80 00 00 li r4,0
ffc09be4: 48 00 15 99 bl ffc0b17c <pthread_attr_setdetachstate>
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
ffc09be8: 2f 83 00 00 cmpwi cr7,r3,0
ffc09bec: 40 9e 00 94 bne- cr7,ffc09c80 <rtems_aio_init+0xf4> <== NEVER TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
ffc09bf0: 3f e0 00 00 lis r31,0
ffc09bf4: 3b ff 2c 70 addi r31,r31,11376
ffc09bf8: 7f e3 fb 78 mr r3,r31
ffc09bfc: 38 80 00 00 li r4,0
ffc09c00: 48 00 11 9d bl ffc0ad9c <pthread_mutex_init>
if (result != 0)
ffc09c04: 2f 83 00 00 cmpwi cr7,r3,0
ffc09c08: 40 9e 00 9c bne- cr7,ffc09ca4 <rtems_aio_init+0x118> <== NEVER TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
ffc09c0c: 3c 60 00 00 lis r3,0
ffc09c10: 38 63 2c 74 addi r3,r3,11380
ffc09c14: 38 80 00 00 li r4,0
ffc09c18: 48 00 0c 19 bl ffc0a830 <pthread_cond_init>
if (result != 0) {
ffc09c1c: 7c 7d 1b 79 mr. r29,r3
ffc09c20: 40 82 00 a4 bne- ffc09cc4 <rtems_aio_init+0x138> <== NEVER TAKEN
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
ffc09c24: 38 00 00 00 li r0,0
aio_request_queue.active_threads = 0;
aio_request_queue.idle_threads = 0;
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
return result;
}
ffc09c28: 83 c1 00 10 lwz r30,16(r1)
ffc09c2c: 90 1f 00 4c stw r0,76(r31)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc09c30: 39 1f 00 4c addi r8,r31,76
head->previous = NULL;
tail->previous = head;
ffc09c34: 39 5f 00 48 addi r10,r31,72
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
ffc09c38: 90 1f 00 58 stw r0,88(r31)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc09c3c: 39 7f 00 58 addi r11,r31,88
head->previous = NULL;
tail->previous = head;
ffc09c40: 39 3f 00 54 addi r9,r31,84
}
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
ffc09c44: 90 1f 00 64 stw r0,100(r31)
aio_request_queue.idle_threads = 0;
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
return result;
}
ffc09c48: 7f a3 eb 78 mr r3,r29
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;
ffc09c4c: 90 1f 00 68 stw r0,104(r31)
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
ffc09c50: 60 00 b0 0b ori r0,r0,45067
ffc09c54: 90 1f 00 60 stw r0,96(r31)
return result;
}
ffc09c58: 80 01 00 1c lwz r0,28(r1)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc09c5c: 91 1f 00 48 stw r8,72(r31)
ffc09c60: 7c 08 03 a6 mtlr r0
head->previous = NULL;
tail->previous = head;
ffc09c64: 91 5f 00 50 stw r10,80(r31)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc09c68: 91 7f 00 54 stw r11,84(r31)
head->previous = NULL;
tail->previous = head;
ffc09c6c: 91 3f 00 5c stw r9,92(r31)
ffc09c70: 83 a1 00 0c lwz r29,12(r1)
ffc09c74: 83 e1 00 14 lwz r31,20(r1)
ffc09c78: 38 21 00 18 addi r1,r1,24
ffc09c7c: 4e 80 00 20 blr
PTHREAD_CREATE_DETACHED);
if (result != 0)
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
ffc09c80: 3f e0 00 00 lis r31,0 <== NOT EXECUTED
result =
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
pthread_attr_destroy (&aio_request_queue.attr);
ffc09c84: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
ffc09c88: 3b ff 2c 70 addi r31,r31,11376 <== NOT EXECUTED
result =
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
pthread_attr_destroy (&aio_request_queue.attr);
ffc09c8c: 48 00 14 89 bl ffc0b114 <pthread_attr_destroy> <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
ffc09c90: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc09c94: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc09c98: 48 00 11 05 bl ffc0ad9c <pthread_mutex_init> <== NOT EXECUTED
if (result != 0)
ffc09c9c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc09ca0: 41 9e ff 6c beq+ cr7,ffc09c0c <rtems_aio_init+0x80> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
ffc09ca4: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc09ca8: 48 00 14 6d bl ffc0b114 <pthread_attr_destroy> <== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
ffc09cac: 3c 60 00 00 lis r3,0 <== NOT EXECUTED
ffc09cb0: 38 63 2c 74 addi r3,r3,11380 <== NOT EXECUTED
ffc09cb4: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc09cb8: 48 00 0b 79 bl ffc0a830 <pthread_cond_init> <== NOT EXECUTED
if (result != 0) {
ffc09cbc: 7c 7d 1b 79 mr. r29,r3 <== NOT EXECUTED
ffc09cc0: 41 82 ff 64 beq+ ffc09c24 <rtems_aio_init+0x98> <== NOT EXECUTED
pthread_mutex_destroy (&aio_request_queue.mutex);
ffc09cc4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc09cc8: 48 00 0f 11 bl ffc0abd8 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
ffc09ccc: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc09cd0: 48 00 14 45 bl ffc0b114 <pthread_attr_destroy> <== NOT EXECUTED
ffc09cd4: 4b ff ff 50 b ffc09c24 <rtems_aio_init+0x98> <== NOT EXECUTED
ffc0a158 <rtems_aio_insert_prio>:
* NONE
*/
void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
ffc0a158: 7c 08 02 a6 mflr r0
ffc0a15c: 94 21 ff f8 stwu r1,-8(r1)
ffc0a160: 7c 8b 23 78 mr r11,r4
ffc0a164: 90 01 00 0c stw r0,12(r1)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
ffc0a168: 38 03 00 04 addi r0,r3,4
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc0a16c: 81 23 00 00 lwz r9,0(r3)
rtems_chain_node *node;
AIO_printf ("FD exists \n");
node = rtems_chain_first (chain);
if (rtems_chain_is_empty (chain)) {
ffc0a170: 7f 89 00 00 cmpw cr7,r9,r0
ffc0a174: 41 9e 00 44 beq- cr7,ffc0a1b8 <rtems_aio_insert_prio+0x60><== NEVER TAKEN
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 &&
ffc0a178: 81 04 00 14 lwz r8,20(r4)
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;
ffc0a17c: 81 49 00 14 lwz r10,20(r9)
while (req->aiocbp->aio_reqprio > prio &&
ffc0a180: 81 08 00 18 lwz r8,24(r8)
ffc0a184: 81 4a 00 18 lwz r10,24(r10)
ffc0a188: 7f 8a 40 00 cmpw cr7,r10,r8
ffc0a18c: 41 bc 00 0c blt+ cr7,ffc0a198 <rtems_aio_insert_prio+0x40><== NEVER TAKEN
ffc0a190: 48 00 00 20 b ffc0a1b0 <rtems_aio_insert_prio+0x58>
ffc0a194: 41 9a 00 1c beq- cr6,ffc0a1b0 <rtems_aio_insert_prio+0x58><== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
ffc0a198: 81 29 00 00 lwz r9,0(r9) <== 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;
ffc0a19c: 81 49 00 14 lwz r10,20(r9) <== 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 &&
ffc0a1a0: 7f 09 00 00 cmpw cr6,r9,r0 <== NOT EXECUTED
ffc0a1a4: 81 4a 00 18 lwz r10,24(r10) <== NOT EXECUTED
ffc0a1a8: 7f 8a 40 00 cmpw cr7,r10,r8 <== NOT EXECUTED
ffc0a1ac: 41 9c ff e8 blt+ cr7,ffc0a194 <rtems_aio_insert_prio+0x3c><== 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 );
ffc0a1b0: 80 69 00 04 lwz r3,4(r9)
ffc0a1b4: 7d 64 5b 78 mr r4,r11
ffc0a1b8: 48 00 30 3d bl ffc0d1f4 <_Chain_Insert>
}
rtems_chain_insert (node->previous, &req->next_prio);
}
}
ffc0a1bc: 80 01 00 0c lwz r0,12(r1)
ffc0a1c0: 38 21 00 08 addi r1,r1,8
ffc0a1c4: 7c 08 03 a6 mtlr r0
ffc0a1c8: 4e 80 00 20 blr
ffc09e14 <rtems_aio_move_to_work>:
* NONE
*/
void
rtems_aio_move_to_work (rtems_aio_request_chain *r_chain)
{
ffc09e14: 7c 08 02 a6 mflr r0
ffc09e18: 94 21 ff f8 stwu r1,-8(r1)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc09e1c: 3d 60 00 00 lis r11,0
ffc09e20: 90 01 00 0c stw r0,12(r1)
ffc09e24: 39 6b 2c 70 addi r11,r11,11376
ffc09e28: 7c 64 1b 78 mr r4,r3
ffc09e2c: 81 2b 00 48 lwz r9,72(r11)
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 &&
ffc09e30: 81 03 00 14 lwz r8,20(r3)
ffc09e34: 80 09 00 14 lwz r0,20(r9)
ffc09e38: 7d 2a 4b 78 mr r10,r9
ffc09e3c: 7f 80 40 00 cmpw cr7,r0,r8
ffc09e40: 40 9c 00 30 bge- cr7,ffc09e70 <rtems_aio_move_to_work+0x5c><== NEVER TAKEN
ffc09e44: 39 6b 00 4c addi r11,r11,76
ffc09e48: 7f 89 58 00 cmpw cr7,r9,r11
ffc09e4c: 40 be 00 0c bne+ cr7,ffc09e58 <rtems_aio_move_to_work+0x44><== ALWAYS TAKEN
ffc09e50: 48 00 00 20 b ffc09e70 <rtems_aio_move_to_work+0x5c> <== NOT EXECUTED
ffc09e54: 41 9a 00 34 beq- cr6,ffc09e88 <rtems_aio_move_to_work+0x74><== NEVER TAKEN
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
ffc09e58: 81 49 00 00 lwz r10,0(r9)
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 &&
ffc09e5c: 80 0a 00 14 lwz r0,20(r10)
ffc09e60: 7f 0a 58 00 cmpw cr6,r10,r11
ffc09e64: 7d 49 53 78 mr r9,r10
ffc09e68: 7f 80 40 00 cmpw cr7,r0,r8
ffc09e6c: 41 9c ff e8 blt+ cr7,ffc09e54 <rtems_aio_move_to_work+0x40>
ffc09e70: 80 6a 00 04 lwz r3,4(r10)
ffc09e74: 48 00 33 81 bl ffc0d1f4 <_Chain_Insert>
node = rtems_chain_next (node);
temp = (rtems_aio_request_chain *) node;
}
rtems_chain_insert (rtems_chain_previous (node), &r_chain->next_fd);
}
ffc09e78: 80 01 00 0c lwz r0,12(r1)
ffc09e7c: 38 21 00 08 addi r1,r1,8
ffc09e80: 7c 08 03 a6 mtlr r0
ffc09e84: 4e 80 00 20 blr
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 &&
ffc09e88: 7d 6a 5b 78 mr r10,r11 <== NOT EXECUTED
ffc09e8c: 80 6a 00 04 lwz r3,4(r10) <== NOT EXECUTED
ffc09e90: 48 00 33 65 bl ffc0d1f4 <_Chain_Insert> <== NOT EXECUTED
node = rtems_chain_next (node);
temp = (rtems_aio_request_chain *) node;
}
rtems_chain_insert (rtems_chain_previous (node), &r_chain->next_fd);
}
ffc09e94: 80 01 00 0c lwz r0,12(r1) <== NOT EXECUTED
ffc09e98: 38 21 00 08 addi r1,r1,8 <== NOT EXECUTED
ffc09e9c: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc09ea0: 4e 80 00 20 blr <== NOT EXECUTED
ffc0a1cc <rtems_aio_remove_fd>:
* Output parameters:
* NONE
*/
void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain)
{
ffc0a1cc: 94 21 ff e0 stwu r1,-32(r1)
ffc0a1d0: 7c 08 02 a6 mflr r0
ffc0a1d4: 90 01 00 24 stw r0,36(r1)
ffc0a1d8: 93 e1 00 1c stw r31,28(r1)
ffc0a1dc: 83 e3 00 08 lwz r31,8(r3)
ffc0a1e0: 93 a1 00 14 stw r29,20(r1)
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
ffc0a1e4: 3b a3 00 0c addi r29,r3,12
rtems_chain_control *chain;
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
ffc0a1e8: 7f 9f e8 00 cmpw cr7,r31,r29
* Output parameters:
* NONE
*/
void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain)
{
ffc0a1ec: 93 61 00 0c stw r27,12(r1)
ffc0a1f0: 93 81 00 10 stw r28,16(r1)
ffc0a1f4: 93 c1 00 18 stw r30,24(r1)
rtems_chain_control *chain;
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
ffc0a1f8: 41 9e 00 38 beq- cr7,ffc0a230 <rtems_aio_remove_fd+0x64><== NEVER TAKEN
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
ffc0a1fc: 3b 60 00 8c li r27,140
req->aiocbp->return_value = -1;
ffc0a200: 3b 80 ff ff li r28,-1
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
ffc0a204: 7f e3 fb 78 mr r3,r31
ffc0a208: 48 00 2f 85 bl ffc0d18c <_Chain_Extract>
while (!rtems_chain_is_tail (chain, node))
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
ffc0a20c: 81 3f 00 14 lwz r9,20(r31)
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
ffc0a210: 83 df 00 00 lwz r30,0(r31)
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
req->aiocbp->return_value = -1;
free (req);
ffc0a214: 7f e3 fb 78 mr r3,r31
while (!rtems_chain_is_tail (chain, node))
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
ffc0a218: 93 69 00 34 stw r27,52(r9)
while (!rtems_chain_is_tail (chain, node))
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
ffc0a21c: 7f df f3 78 mr r31,r30
req->aiocbp->error_code = ECANCELED;
req->aiocbp->return_value = -1;
ffc0a220: 93 89 00 38 stw r28,56(r9)
free (req);
ffc0a224: 4b ff b7 ed bl ffc05a10 <free>
rtems_chain_control *chain;
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
ffc0a228: 7f 9e e8 00 cmpw cr7,r30,r29
ffc0a22c: 40 9e ff d8 bne+ cr7,ffc0a204 <rtems_aio_remove_fd+0x38>
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
req->aiocbp->return_value = -1;
free (req);
}
}
ffc0a230: 80 01 00 24 lwz r0,36(r1)
ffc0a234: 83 61 00 0c lwz r27,12(r1)
ffc0a238: 7c 08 03 a6 mtlr r0
ffc0a23c: 83 81 00 10 lwz r28,16(r1)
ffc0a240: 83 a1 00 14 lwz r29,20(r1)
ffc0a244: 83 c1 00 18 lwz r30,24(r1)
ffc0a248: 83 e1 00 1c lwz r31,28(r1)
ffc0a24c: 38 21 00 20 addi r1,r1,32
ffc0a250: 4e 80 00 20 blr
ffc0a254 <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)
{
ffc0a254: 94 21 ff f0 stwu r1,-16(r1)
ffc0a258: 7c 08 02 a6 mflr r0
ffc0a25c: 90 01 00 14 stw r0,20(r1)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
ffc0a260: 38 03 00 04 addi r0,r3,4
ffc0a264: 93 e1 00 0c stw r31,12(r1)
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
ffc0a268: 83 e3 00 00 lwz r31,0(r3)
if (rtems_chain_is_empty (chain))
return AIO_ALLDONE;
ffc0a26c: 38 60 00 02 li r3,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))
ffc0a270: 7f 9f 00 00 cmpw cr7,r31,r0
ffc0a274: 40 be 00 14 bne+ cr7,ffc0a288 <rtems_aio_remove_req+0x34>
ffc0a278: 48 00 00 44 b ffc0a2bc <rtems_aio_remove_req+0x68>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
ffc0a27c: 83 ff 00 00 lwz r31,0(r31) <== 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) {
ffc0a280: 7f 9f 00 00 cmpw cr7,r31,r0 <== NOT EXECUTED
ffc0a284: 41 9e 00 4c beq- cr7,ffc0a2d0 <rtems_aio_remove_req+0x7c><== NOT EXECUTED
ffc0a288: 81 3f 00 14 lwz r9,20(r31)
ffc0a28c: 7f 89 20 00 cmpw cr7,r9,r4
ffc0a290: 40 9e ff ec bne+ cr7,ffc0a27c <rtems_aio_remove_req+0x28><== NEVER TAKEN
ffc0a294: 7f e3 fb 78 mr r3,r31
ffc0a298: 48 00 2e f5 bl ffc0d18c <_Chain_Extract>
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
ffc0a29c: 81 3f 00 14 lwz r9,20(r31)
ffc0a2a0: 38 00 00 8c li r0,140
ffc0a2a4: 90 09 00 34 stw r0,52(r9)
current->aiocbp->return_value = -1;
ffc0a2a8: 38 00 ff ff li r0,-1
free (current);
ffc0a2ac: 7f e3 fb 78 mr r3,r31
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
current->aiocbp->return_value = -1;
ffc0a2b0: 90 09 00 38 stw r0,56(r9)
free (current);
ffc0a2b4: 4b ff b7 5d bl ffc05a10 <free>
}
return AIO_CANCELED;
ffc0a2b8: 38 60 00 00 li r3,0
}
ffc0a2bc: 80 01 00 14 lwz r0,20(r1)
ffc0a2c0: 83 e1 00 0c lwz r31,12(r1)
ffc0a2c4: 38 21 00 10 addi r1,r1,16
ffc0a2c8: 7c 08 03 a6 mtlr r0
ffc0a2cc: 4e 80 00 20 blr
ffc0a2d0: 80 01 00 14 lwz r0,20(r1) <== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
ffc0a2d4: 38 60 00 01 li r3,1 <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
ffc0a2d8: 83 e1 00 0c lwz r31,12(r1) <== NOT EXECUTED
ffc0a2dc: 38 21 00 10 addi r1,r1,16 <== NOT EXECUTED
ffc0a2e0: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc0a2e4: 4e 80 00 20 blr <== NOT EXECUTED
ffc12ff0 <rtems_assoc_local_by_remote_bitfield>:
uint32_t rtems_assoc_local_by_remote_bitfield(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
ffc12ff0: 94 21 ff e0 stwu r1,-32(r1)
ffc12ff4: 7c 08 02 a6 mflr r0
ffc12ff8: 90 01 00 24 stw r0,36(r1)
ffc12ffc: 38 00 00 20 li r0,32
ffc13000: 93 81 00 10 stw r28,16(r1)
ffc13004: 7c 7c 1b 78 mr r28,r3
ffc13008: 93 a1 00 14 stw r29,20(r1)
uint32_t b;
uint32_t local_value = 0;
ffc1300c: 3b a0 00 00 li r29,0
uint32_t rtems_assoc_local_by_remote_bitfield(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
ffc13010: 93 c1 00 18 stw r30,24(r1)
ffc13014: 7c 9e 23 78 mr r30,r4
ffc13018: 93 e1 00 1c stw r31,28(r1)
uint32_t b;
uint32_t local_value = 0;
for (b = 1; b; b <<= 1) {
ffc1301c: 3b e0 00 01 li r31,1
uint32_t rtems_assoc_local_by_remote_bitfield(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
ffc13020: 90 01 00 08 stw r0,8(r1)
ffc13024: 48 00 00 18 b ffc1303c <rtems_assoc_local_by_remote_bitfield+0x4c>
uint32_t b;
uint32_t local_value = 0;
for (b = 1; b; b <<= 1) {
ffc13028: 80 01 00 08 lwz r0,8(r1)
ffc1302c: 57 ff 08 3c rlwinm r31,r31,1,0,30
ffc13030: 35 20 ff ff addic. r9,r0,-1
ffc13034: 91 21 00 08 stw r9,8(r1)
ffc13038: 41 82 00 30 beq- ffc13068 <rtems_assoc_local_by_remote_bitfield+0x78>
if (b & remote_value)
ffc1303c: 7f e9 f0 39 and. r9,r31,r30
ffc13040: 41 82 ff e8 beq+ ffc13028 <rtems_assoc_local_by_remote_bitfield+0x38>
local_value |= rtems_assoc_local_by_remote(ap, b);
ffc13044: 7f e4 fb 78 mr r4,r31
ffc13048: 7f 83 e3 78 mr r3,r28
ffc1304c: 48 00 00 41 bl ffc1308c <rtems_assoc_local_by_remote>
)
{
uint32_t b;
uint32_t local_value = 0;
for (b = 1; b; b <<= 1) {
ffc13050: 80 01 00 08 lwz r0,8(r1)
if (b & remote_value)
local_value |= rtems_assoc_local_by_remote(ap, b);
ffc13054: 7f bd 1b 78 or r29,r29,r3
)
{
uint32_t b;
uint32_t local_value = 0;
for (b = 1; b; b <<= 1) {
ffc13058: 35 20 ff ff addic. r9,r0,-1
ffc1305c: 57 ff 08 3c rlwinm r31,r31,1,0,30
ffc13060: 91 21 00 08 stw r9,8(r1)
ffc13064: 40 82 ff d8 bne+ ffc1303c <rtems_assoc_local_by_remote_bitfield+0x4c><== ALWAYS TAKEN
if (b & remote_value)
local_value |= rtems_assoc_local_by_remote(ap, b);
}
return local_value;
}
ffc13068: 80 01 00 24 lwz r0,36(r1)
ffc1306c: 7f a3 eb 78 mr r3,r29
ffc13070: 83 81 00 10 lwz r28,16(r1)
ffc13074: 7c 08 03 a6 mtlr r0
ffc13078: 83 a1 00 14 lwz r29,20(r1)
ffc1307c: 83 c1 00 18 lwz r30,24(r1)
ffc13080: 83 e1 00 1c lwz r31,28(r1)
ffc13084: 38 21 00 20 addi r1,r1,32
ffc13088: 4e 80 00 20 blr
ffc0f2e4 <rtems_assoc_ptr_by_local>:
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
ffc0f2e4: 94 21 ff f0 stwu r1,-16(r1)
ffc0f2e8: 7c 08 02 a6 mflr r0
ffc0f2ec: 90 01 00 14 stw r0,20(r1)
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
ffc0f2f0: 80 03 00 00 lwz r0,0(r3)
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
ffc0f2f4: 93 c1 00 08 stw r30,8(r1)
ffc0f2f8: 7c 7e 1b 78 mr r30,r3
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
ffc0f2fc: 2f 80 00 00 cmpwi cr7,r0,0
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
ffc0f300: 93 e1 00 0c stw r31,12(r1)
const rtems_assoc_t *default_ap = 0;
ffc0f304: 38 60 00 00 li r3,0
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
ffc0f308: 7c 9f 23 78 mr r31,r4
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
ffc0f30c: 41 9e 00 68 beq- cr7,ffc0f374 <rtems_assoc_ptr_by_local+0x90>
ffc0f310: 3c 80 ff c2 lis r4,-62
ffc0f314: 7c 03 03 78 mr r3,r0
ffc0f318: 38 84 0e 78 addi r4,r4,3704
ffc0f31c: 48 00 5d c1 bl ffc150dc <strcmp>
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
const rtems_assoc_t *default_ap = 0;
ffc0f320: 39 00 00 00 li r8,0
if (rtems_assoc_is_default(ap))
ffc0f324: 2f 83 00 00 cmpwi cr7,r3,0
ffc0f328: 41 9e 00 64 beq- cr7,ffc0f38c <rtems_assoc_ptr_by_local+0xa8>
default_ap = ap++;
for ( ; ap->name; ap++)
if (ap->local_value == local_value)
ffc0f32c: 80 1e 00 04 lwz r0,4(r30)
ffc0f330: 7f c3 f3 78 mr r3,r30
ffc0f334: 7f 80 f8 00 cmpw cr7,r0,r31
ffc0f338: 41 9e 00 3c beq- cr7,ffc0f374 <rtems_assoc_ptr_by_local+0x90>
ffc0f33c: 39 3e 00 0c addi r9,r30,12
ffc0f340: 7c 1e 00 d0 neg r0,r30
ffc0f344: 48 00 00 10 b ffc0f354 <rtems_assoc_ptr_by_local+0x70>
ffc0f348: 81 6a ff f8 lwz r11,-8(r10)
ffc0f34c: 7f 8b f8 00 cmpw cr7,r11,r31
ffc0f350: 41 9e 00 24 beq- cr7,ffc0f374 <rtems_assoc_ptr_by_local+0x90>
#include <rtems.h>
#include <rtems/assoc.h>
#include <string.h> /* strcat, strcmp */
const rtems_assoc_t *rtems_assoc_ptr_by_local(
ffc0f354: 7d 63 02 14 add r11,r3,r0
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
ffc0f358: 7d 69 58 2e lwzx r11,r9,r11
ffc0f35c: 38 63 00 0c addi r3,r3,12
#include <rtems.h>
#include <rtems/assoc.h>
#include <string.h> /* strcat, strcmp */
const rtems_assoc_t *rtems_assoc_ptr_by_local(
ffc0f360: 7d 43 02 14 add r10,r3,r0
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
ffc0f364: 2f 8b 00 00 cmpwi cr7,r11,0
#include <rtems.h>
#include <rtems/assoc.h>
#include <string.h> /* strcat, strcmp */
const rtems_assoc_t *rtems_assoc_ptr_by_local(
ffc0f368: 7d 49 52 14 add r10,r9,r10
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
ffc0f36c: 40 9e ff dc bne+ cr7,ffc0f348 <rtems_assoc_ptr_by_local+0x64>
ffc0f370: 7d 03 43 78 mr r3,r8
if (ap->local_value == local_value)
return ap;
return default_ap;
}
ffc0f374: 80 01 00 14 lwz r0,20(r1)
ffc0f378: 83 c1 00 08 lwz r30,8(r1)
ffc0f37c: 7c 08 03 a6 mtlr r0
ffc0f380: 83 e1 00 0c lwz r31,12(r1)
ffc0f384: 38 21 00 10 addi r1,r1,16
ffc0f388: 4e 80 00 20 blr
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
ffc0f38c: 80 1e 00 0c lwz r0,12(r30)
ffc0f390: 7f c3 f3 78 mr r3,r30
ffc0f394: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f398: 41 be ff dc beq- cr7,ffc0f374 <rtems_assoc_ptr_by_local+0x90><== NEVER TAKEN
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
ffc0f39c: 7f c8 f3 78 mr r8,r30
ffc0f3a0: 3b de 00 0c addi r30,r30,12
ffc0f3a4: 4b ff ff 88 b ffc0f32c <rtems_assoc_ptr_by_local+0x48>
ffc057d4 <rtems_assoc_ptr_by_name>:
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
ffc057d4: 94 21 ff e0 stwu r1,-32(r1)
ffc057d8: 7c 08 02 a6 mflr r0
ffc057dc: 90 01 00 24 stw r0,36(r1)
ffc057e0: 93 e1 00 1c stw r31,28(r1)
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
ffc057e4: 83 e3 00 00 lwz r31,0(r3)
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
ffc057e8: 93 81 00 10 stw r28,16(r1)
ffc057ec: 7c 9c 23 78 mr r28,r4
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
ffc057f0: 2f 9f 00 00 cmpwi cr7,r31,0
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
ffc057f4: 93 a1 00 14 stw r29,20(r1)
ffc057f8: 7c 7d 1b 78 mr r29,r3
ffc057fc: 93 c1 00 18 stw r30,24(r1)
const rtems_assoc_t *default_ap = 0;
ffc05800: 3b c0 00 00 li r30,0
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
ffc05804: 93 41 00 08 stw r26,8(r1)
ffc05808: 93 61 00 0c stw r27,12(r1)
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
ffc0580c: 41 9e 00 5c beq- cr7,ffc05868 <rtems_assoc_ptr_by_name+0x94>
ffc05810: 3c 80 ff c2 lis r4,-62
ffc05814: 7f e3 fb 78 mr r3,r31
ffc05818: 38 84 af f0 addi r4,r4,-20496
ffc0581c: 48 00 fe e1 bl ffc156fc <strcmp>
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
const rtems_assoc_t *default_ap = 0;
ffc05820: 3b 40 00 00 li r26,0
if (rtems_assoc_is_default(ap))
ffc05824: 2f 83 00 00 cmpwi cr7,r3,0
ffc05828: 41 9e 00 6c beq- cr7,ffc05894 <rtems_assoc_ptr_by_name+0xc0>
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
ffc0582c: 7f a0 eb 78 mr r0,r29
#include <rtems/assoc.h>
#include <string.h> /* strcat, strcmp */
const rtems_assoc_t *rtems_assoc_ptr_by_name(
ffc05830: 3b 7d 00 0c addi r27,r29,12
ffc05834: 48 00 00 10 b ffc05844 <rtems_assoc_ptr_by_name+0x70>
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
ffc05838: 83 e9 ff f4 lwz r31,-12(r9)
ffc0583c: 2f 9f 00 00 cmpwi cr7,r31,0
ffc05840: 41 9e 00 70 beq- cr7,ffc058b0 <rtems_assoc_ptr_by_name+0xdc>
if (strcmp(ap->name, name) == 0)
ffc05844: 7f e3 fb 78 mr r3,r31
ffc05848: 7f 84 e3 78 mr r4,r28
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
ffc0584c: 7c 1e 03 78 mr r30,r0
for ( ; ap->name; ap++)
if (strcmp(ap->name, name) == 0)
ffc05850: 48 00 fe ad bl ffc156fc <strcmp>
ffc05854: 2f 83 00 00 cmpwi cr7,r3,0
ffc05858: 38 1e 00 0c addi r0,r30,12
#include <rtems/assoc.h>
#include <string.h> /* strcat, strcmp */
const rtems_assoc_t *rtems_assoc_ptr_by_name(
ffc0585c: 7d 3d 00 50 subf r9,r29,r0
ffc05860: 7d 29 da 14 add r9,r9,r27
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
if (strcmp(ap->name, name) == 0)
ffc05864: 40 9e ff d4 bne+ cr7,ffc05838 <rtems_assoc_ptr_by_name+0x64>
return ap;
return default_ap;
}
ffc05868: 80 01 00 24 lwz r0,36(r1)
ffc0586c: 7f c3 f3 78 mr r3,r30
ffc05870: 83 41 00 08 lwz r26,8(r1)
ffc05874: 7c 08 03 a6 mtlr r0
ffc05878: 83 61 00 0c lwz r27,12(r1)
ffc0587c: 83 81 00 10 lwz r28,16(r1)
ffc05880: 83 a1 00 14 lwz r29,20(r1)
ffc05884: 83 c1 00 18 lwz r30,24(r1)
ffc05888: 83 e1 00 1c lwz r31,28(r1)
ffc0588c: 38 21 00 20 addi r1,r1,32
ffc05890: 4e 80 00 20 blr
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
ffc05894: 83 fd 00 0c lwz r31,12(r29)
ffc05898: 7f be eb 78 mr r30,r29
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
ffc0589c: 7f ba eb 78 mr r26,r29
for ( ; ap->name; ap++)
ffc058a0: 2f 9f 00 00 cmpwi cr7,r31,0
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
ffc058a4: 3b bd 00 0c addi r29,r29,12
for ( ; ap->name; ap++)
ffc058a8: 40 9e ff 84 bne+ cr7,ffc0582c <rtems_assoc_ptr_by_name+0x58><== ALWAYS TAKEN
ffc058ac: 4b ff ff bc b ffc05868 <rtems_assoc_ptr_by_name+0x94><== NOT EXECUTED
if (strcmp(ap->name, name) == 0)
return ap;
return default_ap;
}
ffc058b0: 80 01 00 24 lwz r0,36(r1)
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
ffc058b4: 7f 5e d3 78 mr r30,r26
if (strcmp(ap->name, name) == 0)
return ap;
return default_ap;
}
ffc058b8: 7f c3 f3 78 mr r3,r30
ffc058bc: 83 41 00 08 lwz r26,8(r1)
ffc058c0: 7c 08 03 a6 mtlr r0
ffc058c4: 83 61 00 0c lwz r27,12(r1)
ffc058c8: 83 81 00 10 lwz r28,16(r1)
ffc058cc: 83 a1 00 14 lwz r29,20(r1)
ffc058d0: 83 c1 00 18 lwz r30,24(r1)
ffc058d4: 83 e1 00 1c lwz r31,28(r1)
ffc058d8: 38 21 00 20 addi r1,r1,32
ffc058dc: 4e 80 00 20 blr
ffc130c8 <rtems_assoc_ptr_by_remote>:
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
ffc130c8: 94 21 ff f0 stwu r1,-16(r1)
ffc130cc: 7c 08 02 a6 mflr r0
ffc130d0: 90 01 00 14 stw r0,20(r1)
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
ffc130d4: 80 03 00 00 lwz r0,0(r3)
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
ffc130d8: 93 c1 00 08 stw r30,8(r1)
ffc130dc: 7c 7e 1b 78 mr r30,r3
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
ffc130e0: 2f 80 00 00 cmpwi cr7,r0,0
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
ffc130e4: 93 e1 00 0c stw r31,12(r1)
const rtems_assoc_t *default_ap = 0;
ffc130e8: 38 60 00 00 li r3,0
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
ffc130ec: 7c 9f 23 78 mr r31,r4
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
ffc130f0: 41 9e 00 68 beq- cr7,ffc13158 <rtems_assoc_ptr_by_remote+0x90>
ffc130f4: 3c 80 ff c2 lis r4,-62
ffc130f8: 7c 03 03 78 mr r3,r0
ffc130fc: 38 84 0e 78 addi r4,r4,3704
ffc13100: 48 00 1f dd bl ffc150dc <strcmp>
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
const rtems_assoc_t *default_ap = 0;
ffc13104: 39 00 00 00 li r8,0
if (rtems_assoc_is_default(ap))
ffc13108: 2f 83 00 00 cmpwi cr7,r3,0
ffc1310c: 41 9e 00 64 beq- cr7,ffc13170 <rtems_assoc_ptr_by_remote+0xa8>
default_ap = ap++;
for ( ; ap->name; ap++)
if (ap->remote_value == remote_value)
ffc13110: 80 1e 00 08 lwz r0,8(r30)
ffc13114: 7f c3 f3 78 mr r3,r30
ffc13118: 7f 80 f8 00 cmpw cr7,r0,r31
ffc1311c: 41 9e 00 3c beq- cr7,ffc13158 <rtems_assoc_ptr_by_remote+0x90>
ffc13120: 39 3e 00 0c addi r9,r30,12
ffc13124: 7c 1e 00 d0 neg r0,r30
ffc13128: 48 00 00 10 b ffc13138 <rtems_assoc_ptr_by_remote+0x70>
ffc1312c: 81 6a ff fc lwz r11,-4(r10)
ffc13130: 7f 8b f8 00 cmpw cr7,r11,r31
ffc13134: 41 9e 00 24 beq- cr7,ffc13158 <rtems_assoc_ptr_by_remote+0x90>
#include <rtems.h>
#include <rtems/assoc.h>
#include <string.h> /* strcat, strcmp */
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
ffc13138: 7d 63 02 14 add r11,r3,r0
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
ffc1313c: 7d 69 58 2e lwzx r11,r9,r11
ffc13140: 38 63 00 0c addi r3,r3,12
#include <rtems.h>
#include <rtems/assoc.h>
#include <string.h> /* strcat, strcmp */
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
ffc13144: 7d 43 02 14 add r10,r3,r0
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
ffc13148: 2f 8b 00 00 cmpwi cr7,r11,0
#include <rtems.h>
#include <rtems/assoc.h>
#include <string.h> /* strcat, strcmp */
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
ffc1314c: 7d 49 52 14 add r10,r9,r10
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
ffc13150: 40 9e ff dc bne+ cr7,ffc1312c <rtems_assoc_ptr_by_remote+0x64>
ffc13154: 7d 03 43 78 mr r3,r8
if (ap->remote_value == remote_value)
return ap;
return default_ap;
}
ffc13158: 80 01 00 14 lwz r0,20(r1)
ffc1315c: 83 c1 00 08 lwz r30,8(r1)
ffc13160: 7c 08 03 a6 mtlr r0
ffc13164: 83 e1 00 0c lwz r31,12(r1)
ffc13168: 38 21 00 10 addi r1,r1,16
ffc1316c: 4e 80 00 20 blr
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
ffc13170: 80 1e 00 0c lwz r0,12(r30)
ffc13174: 7f c3 f3 78 mr r3,r30
ffc13178: 2f 80 00 00 cmpwi cr7,r0,0
ffc1317c: 41 be ff dc beq- cr7,ffc13158 <rtems_assoc_ptr_by_remote+0x90><== NEVER TAKEN
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
ffc13180: 7f c8 f3 78 mr r8,r30
ffc13184: 3b de 00 0c addi r30,r30,12
ffc13188: 4b ff ff 88 b ffc13110 <rtems_assoc_ptr_by_remote+0x48>
ffc059a4 <rtems_assoc_remote_by_local_bitfield>:
uint32_t rtems_assoc_remote_by_local_bitfield(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
ffc059a4: 94 21 ff e0 stwu r1,-32(r1)
ffc059a8: 7c 08 02 a6 mflr r0
ffc059ac: 90 01 00 24 stw r0,36(r1)
ffc059b0: 38 00 00 20 li r0,32
ffc059b4: 93 81 00 10 stw r28,16(r1)
ffc059b8: 7c 7c 1b 78 mr r28,r3
ffc059bc: 93 a1 00 14 stw r29,20(r1)
uint32_t b;
uint32_t remote_value = 0;
ffc059c0: 3b a0 00 00 li r29,0
uint32_t rtems_assoc_remote_by_local_bitfield(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
ffc059c4: 93 c1 00 18 stw r30,24(r1)
ffc059c8: 7c 9e 23 78 mr r30,r4
ffc059cc: 93 e1 00 1c stw r31,28(r1)
uint32_t b;
uint32_t remote_value = 0;
for (b = 1; b; b <<= 1)
ffc059d0: 3b e0 00 01 li r31,1
uint32_t rtems_assoc_remote_by_local_bitfield(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
ffc059d4: 90 01 00 08 stw r0,8(r1)
ffc059d8: 48 00 00 18 b ffc059f0 <rtems_assoc_remote_by_local_bitfield+0x4c>
uint32_t b;
uint32_t remote_value = 0;
for (b = 1; b; b <<= 1)
ffc059dc: 80 01 00 08 lwz r0,8(r1)
ffc059e0: 57 ff 08 3c rlwinm r31,r31,1,0,30
ffc059e4: 35 20 ff ff addic. r9,r0,-1
ffc059e8: 91 21 00 08 stw r9,8(r1)
ffc059ec: 41 82 00 30 beq- ffc05a1c <rtems_assoc_remote_by_local_bitfield+0x78>
if (b & local_value)
ffc059f0: 7f e9 f0 39 and. r9,r31,r30
ffc059f4: 41 82 ff e8 beq+ ffc059dc <rtems_assoc_remote_by_local_bitfield+0x38>
remote_value |= rtems_assoc_remote_by_local(ap, b);
ffc059f8: 7f e4 fb 78 mr r4,r31
ffc059fc: 7f 83 e3 78 mr r3,r28
ffc05a00: 48 00 00 41 bl ffc05a40 <rtems_assoc_remote_by_local>
)
{
uint32_t b;
uint32_t remote_value = 0;
for (b = 1; b; b <<= 1)
ffc05a04: 80 01 00 08 lwz r0,8(r1)
if (b & local_value)
remote_value |= rtems_assoc_remote_by_local(ap, b);
ffc05a08: 7f bd 1b 78 or r29,r29,r3
)
{
uint32_t b;
uint32_t remote_value = 0;
for (b = 1; b; b <<= 1)
ffc05a0c: 35 20 ff ff addic. r9,r0,-1
ffc05a10: 57 ff 08 3c rlwinm r31,r31,1,0,30
ffc05a14: 91 21 00 08 stw r9,8(r1)
ffc05a18: 40 82 ff d8 bne+ ffc059f0 <rtems_assoc_remote_by_local_bitfield+0x4c><== ALWAYS TAKEN
if (b & local_value)
remote_value |= rtems_assoc_remote_by_local(ap, b);
return remote_value;
}
ffc05a1c: 80 01 00 24 lwz r0,36(r1)
ffc05a20: 7f a3 eb 78 mr r3,r29
ffc05a24: 83 81 00 10 lwz r28,16(r1)
ffc05a28: 7c 08 03 a6 mtlr r0
ffc05a2c: 83 a1 00 14 lwz r29,20(r1)
ffc05a30: 83 c1 00 18 lwz r30,24(r1)
ffc05a34: 83 e1 00 1c lwz r31,28(r1)
ffc05a38: 38 21 00 20 addi r1,r1,32
ffc05a3c: 4e 80 00 20 blr
ffc0f5e0 <rtems_bdbuf_add_to_modified_list_after_access>:
}
}
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
ffc0f5e0: 94 21 ff f0 stwu r1,-16(r1)
ffc0f5e4: 7c 08 02 a6 mflr r0
ffc0f5e8: 93 c1 00 08 stw r30,8(r1)
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dev)
ffc0f5ec: 3f c0 00 00 lis r30,0
ffc0f5f0: 3b de 2a 08 addi r30,r30,10760
}
}
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
ffc0f5f4: 90 01 00 14 stw r0,20(r1)
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dev)
ffc0f5f8: 88 1e 00 30 lbz r0,48(r30)
}
}
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
ffc0f5fc: 93 e1 00 0c stw r31,12(r1)
ffc0f600: 7c 7f 1b 78 mr r31,r3
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dev)
ffc0f604: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f608: 41 9e 00 18 beq- cr7,ffc0f620 <rtems_bdbuf_add_to_modified_list_after_access+0x40><== ALWAYS TAKEN
ffc0f60c: 81 5e 00 38 lwz r10,56(r30) <== NOT EXECUTED
ffc0f610: 80 03 00 18 lwz r0,24(r3) <== NOT EXECUTED
ffc0f614: 81 7e 00 3c lwz r11,60(r30) <== NOT EXECUTED
ffc0f618: 7f 80 50 00 cmpw cr7,r0,r10 <== NOT EXECUTED
ffc0f61c: 41 9e 00 c0 beq- cr7,ffc0f6dc <rtems_bdbuf_add_to_modified_list_after_access+0xfc><== NOT EXECUTED
* difficult question. Is a snapshot of a block that is changing better than
* nothing being written? We have tended to think we should hold changes for
* only a specific period of time even if still changing and get onto disk
* and letting the file system try and recover this position if it can.
*/
if (bd->state == RTEMS_BDBUF_STATE_ACCESS_CACHED
ffc0f620: 80 1f 00 28 lwz r0,40(r31)
ffc0f624: 2f 80 00 03 cmpwi cr7,r0,3
ffc0f628: 41 9e 00 6c beq- cr7,ffc0f694 <rtems_bdbuf_add_to_modified_list_after_access+0xb4>
|| bd->state == RTEMS_BDBUF_STATE_ACCESS_EMPTY)
ffc0f62c: 80 1f 00 28 lwz r0,40(r31)
ffc0f630: 2f 80 00 05 cmpwi cr7,r0,5
ffc0f634: 41 9e 00 60 beq- cr7,ffc0f694 <rtems_bdbuf_add_to_modified_list_after_access+0xb4>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc0f638: 38 00 00 07 li r0,7
ffc0f63c: 90 1f 00 28 stw r0,40(r31)
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
ffc0f640: 38 7e 00 50 addi r3,r30,80
ffc0f644: 7f e4 fb 78 mr r4,r31
ffc0f648: 4b ff bb 31 bl ffc0b178 <_Chain_Append>
bd->hold_timer = bdbuf_config.swap_block_hold;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);
rtems_chain_append (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
ffc0f64c: 80 1f 00 2c lwz r0,44(r31)
ffc0f650: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f654: 40 9e 00 6c bne- cr7,ffc0f6c0 <rtems_bdbuf_add_to_modified_list_after_access+0xe0>
}
static bool
rtems_bdbuf_has_buffer_waiters (void)
{
return bdbuf_cache.buffer_waiters.count;
ffc0f658: 80 1e 00 78 lwz r0,120(r30)
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);
rtems_chain_append (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
else if (rtems_bdbuf_has_buffer_waiters ())
ffc0f65c: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f660: 40 9e 00 1c bne- cr7,ffc0f67c <rtems_bdbuf_add_to_modified_list_after_access+0x9c>
rtems_bdbuf_wake_swapper ();
}
ffc0f664: 80 01 00 14 lwz r0,20(r1)
ffc0f668: 83 c1 00 08 lwz r30,8(r1)
ffc0f66c: 7c 08 03 a6 mtlr r0
ffc0f670: 83 e1 00 0c lwz r31,12(r1)
ffc0f674: 38 21 00 10 addi r1,r1,16
ffc0f678: 4e 80 00 20 blr
ffc0f67c: 80 01 00 14 lwz r0,20(r1)
ffc0f680: 83 c1 00 08 lwz r30,8(r1)
ffc0f684: 7c 08 03 a6 mtlr r0
ffc0f688: 83 e1 00 0c lwz r31,12(r1)
ffc0f68c: 38 21 00 10 addi r1,r1,16
rtems_chain_append (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
else if (rtems_bdbuf_has_buffer_waiters ())
rtems_bdbuf_wake_swapper ();
ffc0f690: 4b ff fc 40 b ffc0f2d0 <rtems_bdbuf_wake_swapper>
* only a specific period of time even if still changing and get onto disk
* and letting the file system try and recover this position if it can.
*/
if (bd->state == RTEMS_BDBUF_STATE_ACCESS_CACHED
|| bd->state == RTEMS_BDBUF_STATE_ACCESS_EMPTY)
bd->hold_timer = bdbuf_config.swap_block_hold;
ffc0f694: 3d 20 ff c2 lis r9,-62
ffc0f698: 80 09 e1 84 lwz r0,-7804(r9)
ffc0f69c: 38 7e 00 50 addi r3,r30,80
ffc0f6a0: 7f e4 fb 78 mr r4,r31
ffc0f6a4: 90 1f 00 34 stw r0,52(r31)
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc0f6a8: 38 00 00 07 li r0,7
ffc0f6ac: 90 1f 00 28 stw r0,40(r31)
ffc0f6b0: 4b ff ba c9 bl ffc0b178 <_Chain_Append>
bd->hold_timer = bdbuf_config.swap_block_hold;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);
rtems_chain_append (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
ffc0f6b4: 80 1f 00 2c lwz r0,44(r31)
ffc0f6b8: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f6bc: 41 9e ff 9c beq+ cr7,ffc0f658 <rtems_bdbuf_add_to_modified_list_after_access+0x78>
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
else if (rtems_bdbuf_has_buffer_waiters ())
rtems_bdbuf_wake_swapper ();
}
ffc0f6c0: 80 01 00 14 lwz r0,20(r1)
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);
rtems_chain_append (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
ffc0f6c4: 38 7e 00 68 addi r3,r30,104
else if (rtems_bdbuf_has_buffer_waiters ())
rtems_bdbuf_wake_swapper ();
}
ffc0f6c8: 83 e1 00 0c lwz r31,12(r1)
ffc0f6cc: 7c 08 03 a6 mtlr r0
ffc0f6d0: 83 c1 00 08 lwz r30,8(r1)
ffc0f6d4: 38 21 00 10 addi r1,r1,16
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);
rtems_chain_append (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
ffc0f6d8: 4b ff fe c4 b ffc0f59c <rtems_bdbuf_wake>
}
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dev)
ffc0f6dc: 80 03 00 1c lwz r0,28(r3) <== NOT EXECUTED
ffc0f6e0: 7f 80 58 00 cmpw cr7,r0,r11 <== NOT EXECUTED
ffc0f6e4: 40 9e ff 3c bne+ cr7,ffc0f620 <rtems_bdbuf_add_to_modified_list_after_access+0x40><== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
ffc0f6e8: 4b ff fb 3d bl ffc0f224 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
/*
* Wait for the sync lock.
*/
rtems_bdbuf_lock_sync ();
ffc0f6ec: 4b ff f8 f1 bl ffc0efdc <rtems_bdbuf_lock_sync> <== NOT EXECUTED
rtems_bdbuf_unlock_sync ();
ffc0f6f0: 4b ff fb 71 bl ffc0f260 <rtems_bdbuf_unlock_sync> <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
ffc0f6f4: 4b ff f8 a5 bl ffc0ef98 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
ffc0f6f8: 4b ff ff 28 b ffc0f620 <rtems_bdbuf_add_to_modified_list_after_access+0x40><== NOT EXECUTED
ffc0f42c <rtems_bdbuf_anonymous_wait>:
* The function assumes the cache is locked on entry and it will be locked on
* exit.
*/
static void
rtems_bdbuf_anonymous_wait (rtems_bdbuf_waiters *waiters)
{
ffc0f42c: 94 21 ff f0 stwu r1,-16(r1)
ffc0f430: 7c 08 02 a6 mflr r0
ffc0f434: 90 01 00 14 stw r0,20(r1)
rtems_mode prev_mode;
/*
* Indicate we are waiting.
*/
++waiters->count;
ffc0f438: 81 23 00 00 lwz r9,0(r3)
* The function assumes the cache is locked on entry and it will be locked on
* exit.
*/
static void
rtems_bdbuf_anonymous_wait (rtems_bdbuf_waiters *waiters)
{
ffc0f43c: 93 c1 00 08 stw r30,8(r1)
rtems_mode prev_mode;
/*
* Indicate we are waiting.
*/
++waiters->count;
ffc0f440: 38 09 00 01 addi r0,r9,1
* The function assumes the cache is locked on entry and it will be locked on
* exit.
*/
static void
rtems_bdbuf_anonymous_wait (rtems_bdbuf_waiters *waiters)
{
ffc0f444: 93 e1 00 0c stw r31,12(r1)
ffc0f448: 7c 7f 1b 78 mr r31,r3
rtems_mode prev_mode;
/*
* Indicate we are waiting.
*/
++waiters->count;
ffc0f44c: 90 03 00 00 stw r0,0(r3)
* blocking or just hits that window, and before this task has blocked on the
* semaphore. If the preempting task flushes the queue this task will not see
* the flush and may block for ever or until another transaction flushes this
* semaphore.
*/
prev_mode = rtems_bdbuf_disable_preemption ();
ffc0f450: 4b ff ff 4d bl ffc0f39c <rtems_bdbuf_disable_preemption>
ffc0f454: 7c 7e 1b 78 mr r30,r3
/*
* Unlock the cache, wait, and lock the cache when we return.
*/
rtems_bdbuf_unlock_cache ();
ffc0f458: 4b ff fd cd bl ffc0f224 <rtems_bdbuf_unlock_cache>
sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
ffc0f45c: 80 7f 00 04 lwz r3,4(r31)
ffc0f460: 38 80 00 00 li r4,0
ffc0f464: 38 a0 00 00 li r5,0
ffc0f468: 4b ff ad 2d bl ffc0a194 <rtems_semaphore_obtain>
if (sc == RTEMS_TIMEOUT)
ffc0f46c: 2f 83 00 06 cmpwi cr7,r3,6
ffc0f470: 41 9e 00 3c beq- cr7,ffc0f4ac <rtems_bdbuf_anonymous_wait+0x80><== NEVER TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_TO);
if (sc != RTEMS_UNSATISFIED)
ffc0f474: 2f 83 00 0d cmpwi cr7,r3,13
ffc0f478: 40 9e 00 40 bne- cr7,ffc0f4b8 <rtems_bdbuf_anonymous_wait+0x8c><== NEVER TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_2);
rtems_bdbuf_lock_cache ();
ffc0f47c: 4b ff fb 1d bl ffc0ef98 <rtems_bdbuf_lock_cache>
rtems_bdbuf_restore_preemption (prev_mode);
ffc0f480: 7f c3 f3 78 mr r3,r30
ffc0f484: 4b ff ff 65 bl ffc0f3e8 <rtems_bdbuf_restore_preemption>
--waiters->count;
ffc0f488: 81 3f 00 00 lwz r9,0(r31)
}
ffc0f48c: 83 c1 00 08 lwz r30,8(r1)
rtems_bdbuf_lock_cache ();
rtems_bdbuf_restore_preemption (prev_mode);
--waiters->count;
ffc0f490: 38 09 ff ff addi r0,r9,-1
ffc0f494: 90 1f 00 00 stw r0,0(r31)
}
ffc0f498: 80 01 00 14 lwz r0,20(r1)
ffc0f49c: 83 e1 00 0c lwz r31,12(r1)
ffc0f4a0: 38 21 00 10 addi r1,r1,16
ffc0f4a4: 7c 08 03 a6 mtlr r0
ffc0f4a8: 4e 80 00 20 blr
rtems_bdbuf_unlock_cache ();
sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
if (sc == RTEMS_TIMEOUT)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_TO);
ffc0f4ac: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0f4b0: 60 63 00 12 ori r3,r3,18 <== NOT EXECUTED
ffc0f4b4: 4b ff b5 fd bl ffc0aab0 <rtems_fatal_error_occurred> <== NOT EXECUTED
if (sc != RTEMS_UNSATISFIED)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_2);
ffc0f4b8: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0f4bc: 60 63 00 10 ori r3,r3,16 <== NOT EXECUTED
ffc0f4c0: 4b ff b5 f1 bl ffc0aab0 <rtems_fatal_error_occurred> <== NOT EXECUTED
ffc0f39c <rtems_bdbuf_disable_preemption>:
--bd->group->users;
}
static rtems_mode
rtems_bdbuf_disable_preemption (void)
{
ffc0f39c: 94 21 ff e8 stwu r1,-24(r1)
ffc0f3a0: 7c 08 02 a6 mflr r0
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_mode prev_mode = 0;
sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode);
ffc0f3a4: 38 60 01 00 li r3,256
--bd->group->users;
}
static rtems_mode
rtems_bdbuf_disable_preemption (void)
{
ffc0f3a8: 90 01 00 1c stw r0,28(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_mode prev_mode = 0;
ffc0f3ac: 7c 25 0b 78 mr r5,r1
ffc0f3b0: 38 00 00 00 li r0,0
ffc0f3b4: 94 05 00 08 stwu r0,8(r5)
sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode);
ffc0f3b8: 38 80 01 00 li r4,256
ffc0f3bc: 48 00 5b 5d bl ffc14f18 <rtems_task_mode>
if (sc != RTEMS_SUCCESSFUL)
ffc0f3c0: 2f 83 00 00 cmpwi cr7,r3,0
ffc0f3c4: 40 9e 00 18 bne- cr7,ffc0f3dc <rtems_bdbuf_disable_preemption+0x40><== NEVER TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_PREEMPT_DIS);
return prev_mode;
}
ffc0f3c8: 80 01 00 1c lwz r0,28(r1)
ffc0f3cc: 80 61 00 08 lwz r3,8(r1)
ffc0f3d0: 38 21 00 18 addi r1,r1,24
ffc0f3d4: 7c 08 03 a6 mtlr r0
ffc0f3d8: 4e 80 00 20 blr
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_mode prev_mode = 0;
sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_PREEMPT_DIS);
ffc0f3dc: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0f3e0: 60 63 00 0f ori r3,r3,15 <== NOT EXECUTED
ffc0f3e4: 4b ff b6 cd bl ffc0aab0 <rtems_fatal_error_occurred> <== NOT EXECUTED
ffc0ffac <rtems_bdbuf_execute_transfer_request.isra.9>:
req->bufnum = transfer_index;
}
static rtems_status_code
rtems_bdbuf_execute_transfer_request (const rtems_disk_device *dd,
ffc0ffac: 7d 80 00 26 mfcr r12
int result = 0;
uint32_t transfer_index = 0;
bool wake_transfer_waiters = false;
bool wake_buffer_waiters = false;
if (cache_locked)
ffc0ffb0: 2d 86 00 00 cmpwi cr3,r6,0
req->bufnum = transfer_index;
}
static rtems_status_code
rtems_bdbuf_execute_transfer_request (const rtems_disk_device *dd,
ffc0ffb4: 94 21 ff c0 stwu r1,-64(r1)
ffc0ffb8: 7c 08 02 a6 mflr r0
ffc0ffbc: 93 e1 00 3c stw r31,60(r1)
ffc0ffc0: 7c bf 2b 78 mr r31,r5
ffc0ffc4: 90 01 00 44 stw r0,68(r1)
ffc0ffc8: 92 c1 00 18 stw r22,24(r1)
ffc0ffcc: 92 e1 00 1c stw r23,28(r1)
ffc0ffd0: 93 01 00 20 stw r24,32(r1)
ffc0ffd4: 93 21 00 24 stw r25,36(r1)
ffc0ffd8: 93 41 00 28 stw r26,40(r1)
ffc0ffdc: 93 61 00 2c stw r27,44(r1)
ffc0ffe0: 93 81 00 30 stw r28,48(r1)
ffc0ffe4: 93 a1 00 34 stw r29,52(r1)
ffc0ffe8: 93 c1 00 38 stw r30,56(r1)
ffc0ffec: 91 81 00 14 stw r12,20(r1)
int result = 0;
uint32_t transfer_index = 0;
bool wake_transfer_waiters = false;
bool wake_buffer_waiters = false;
if (cache_locked)
ffc0fff0: 40 8e 01 b8 bne- cr3,ffc101a8 <rtems_bdbuf_execute_transfer_request.isra.9+0x1fc>
rtems_bdbuf_unlock_cache ();
result = dd->ioctl (dd->phys_dev, RTEMS_BLKIO_REQUEST, req);
ffc0fff4: 80 04 00 00 lwz r0,0(r4)
ffc0fff8: 3c 80 c0 18 lis r4,-16360
ffc0fffc: 80 63 00 00 lwz r3,0(r3)
ffc10000: 60 84 42 01 ori r4,r4,16897
ffc10004: 7f e5 fb 78 mr r5,r31
ffc10008: 7c 09 03 a6 mtctr r0
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_TRANSFER_SYNC);
sc = req->status;
}
else
sc = RTEMS_IO_ERROR;
ffc1000c: 3b 20 00 1b li r25,27
bool wake_buffer_waiters = false;
if (cache_locked)
rtems_bdbuf_unlock_cache ();
result = dd->ioctl (dd->phys_dev, RTEMS_BLKIO_REQUEST, req);
ffc10010: 4e 80 04 21 bctrl
if (result == 0)
ffc10014: 2f 83 00 00 cmpwi cr7,r3,0
ffc10018: 41 9e 01 80 beq- cr7,ffc10198 <rtems_bdbuf_execute_transfer_request.isra.9+0x1ec>
sc = req->status;
}
else
sc = RTEMS_IO_ERROR;
rtems_bdbuf_lock_cache ();
ffc1001c: 4b ff ef 7d bl ffc0ef98 <rtems_bdbuf_lock_cache>
for (transfer_index = 0; transfer_index < req->bufnum; ++transfer_index)
ffc10020: 81 5f 00 10 lwz r10,16(r31)
ffc10024: 2e 19 00 00 cmpwi cr4,r25,0
ffc10028: 2f 8a 00 00 cmpwi cr7,r10,0
ffc1002c: 41 9e 00 c8 beq- cr7,ffc100f4 <rtems_bdbuf_execute_transfer_request.isra.9+0x148><== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head(
Chain_Control *the_chain
)
{
return &the_chain->Head.Node;
ffc10030: 3f 40 00 00 lis r26,0
ffc10034: 3b 5a 2a 08 addi r26,r26,10760
ffc10038: 3b c0 00 01 li r30,1
ffc1003c: 3b 80 00 00 li r28,0
ffc10040: 3b 60 00 00 li r27,0
bool waiters = bd->waiters;
if (waiters)
wake_transfer_waiters = true;
else
wake_buffer_waiters = true;
ffc10044: 3b a0 00 01 li r29,1
ffc10048: 3b 5a 00 44 addi r26,r26,68
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc1004c: 3b 00 00 02 li r24,2
ffc10050: 48 00 00 48 b ffc10098 <rtems_bdbuf_execute_transfer_request.isra.9+0xec>
{
rtems_bdbuf_buffer *bd = req->bufs [transfer_index].user;
bool waiters = bd->waiters;
if (waiters)
wake_transfer_waiters = true;
ffc10054: 3b 60 00 01 li r27,1
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
ffc10058: 81 37 00 30 lwz r9,48(r23)
ffc1005c: 81 69 00 0c lwz r11,12(r9)
ffc10060: 38 0b ff ff addi r0,r11,-1
ffc10064: 90 09 00 0c stw r0,12(r9)
else
wake_buffer_waiters = true;
rtems_bdbuf_group_release (bd);
if (sc == RTEMS_SUCCESSFUL && bd->state == RTEMS_BDBUF_STATE_TRANSFER)
ffc10068: 40 92 00 10 bne- cr4,ffc10078 <rtems_bdbuf_execute_transfer_request.isra.9+0xcc>
ffc1006c: 80 17 00 28 lwz r0,40(r23)
ffc10070: 2f 80 00 09 cmpwi cr7,r0,9
ffc10074: 41 9e 00 d8 beq- cr7,ffc1014c <rtems_bdbuf_execute_transfer_request.isra.9+0x1a0>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc10078: 93 b7 00 28 stw r29,40(r23)
static void
rtems_bdbuf_discard_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_make_empty (bd);
if (bd->waiters == 0)
ffc1007c: 82 d7 00 2c lwz r22,44(r23)
ffc10080: 2f 96 00 00 cmpwi cr7,r22,0
ffc10084: 41 9e 00 34 beq- cr7,ffc100b8 <rtems_bdbuf_execute_transfer_request.isra.9+0x10c>
else
sc = RTEMS_IO_ERROR;
rtems_bdbuf_lock_cache ();
for (transfer_index = 0; transfer_index < req->bufnum; ++transfer_index)
ffc10088: 7f 8a f0 40 cmplw cr7,r10,r30
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
ffc1008c: 38 1e 00 01 addi r0,r30,1
ffc10090: 7c 1e 03 78 mr r30,r0
ffc10094: 40 9d 00 50 ble- cr7,ffc100e4 <rtems_bdbuf_execute_transfer_request.isra.9+0x138>
req->bufnum = transfer_index;
}
static rtems_status_code
rtems_bdbuf_execute_transfer_request (const rtems_disk_device *dd,
ffc10098: 57 c9 20 36 rlwinm r9,r30,4,0,27
ffc1009c: 7d 3f 4a 14 add r9,r31,r9
rtems_bdbuf_lock_cache ();
for (transfer_index = 0; transfer_index < req->bufnum; ++transfer_index)
{
rtems_bdbuf_buffer *bd = req->bufs [transfer_index].user;
ffc100a0: 82 e9 00 14 lwz r23,20(r9)
bool waiters = bd->waiters;
ffc100a4: 80 17 00 2c lwz r0,44(r23)
if (waiters)
ffc100a8: 2f 80 00 00 cmpwi cr7,r0,0
ffc100ac: 40 be ff a8 bne- cr7,ffc10054 <rtems_bdbuf_execute_transfer_request.isra.9+0xa8>
wake_transfer_waiters = true;
else
wake_buffer_waiters = true;
ffc100b0: 3b 80 00 01 li r28,1
ffc100b4: 4b ff ff a4 b ffc10058 <rtems_bdbuf_execute_transfer_request.isra.9+0xac>
{
rtems_bdbuf_make_empty (bd);
if (bd->waiters == 0)
{
rtems_bdbuf_remove_from_tree (bd);
ffc100b8: 7e e3 bb 78 mr r3,r23
ffc100bc: 4b ff f7 81 bl ffc0f83c <rtems_bdbuf_remove_from_tree>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc100c0: 92 d7 00 28 stw r22,40(r23)
ffc100c4: 7f 43 d3 78 mr r3,r26
ffc100c8: 7e e4 bb 78 mr r4,r23
ffc100cc: 48 00 54 79 bl ffc15544 <_Chain_Insert>
ffc100d0: 81 5f 00 10 lwz r10,16(r31)
ffc100d4: 38 1e 00 01 addi r0,r30,1
else
sc = RTEMS_IO_ERROR;
rtems_bdbuf_lock_cache ();
for (transfer_index = 0; transfer_index < req->bufnum; ++transfer_index)
ffc100d8: 7f 8a f0 40 cmplw cr7,r10,r30
ffc100dc: 7c 1e 03 78 mr r30,r0
ffc100e0: 41 9d ff b8 bgt+ cr7,ffc10098 <rtems_bdbuf_execute_transfer_request.isra.9+0xec><== NEVER TAKEN
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("transfer", bd);
}
if (wake_transfer_waiters)
ffc100e4: 2f 9b 00 00 cmpwi cr7,r27,0
ffc100e8: 40 9e 00 9c bne- cr7,ffc10184 <rtems_bdbuf_execute_transfer_request.isra.9+0x1d8>
rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters);
if (wake_buffer_waiters)
ffc100ec: 2f 9c 00 00 cmpwi cr7,r28,0
ffc100f0: 40 9e 00 7c bne- cr7,ffc1016c <rtems_bdbuf_execute_transfer_request.isra.9+0x1c0>
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
if (!cache_locked)
ffc100f4: 41 8e 00 70 beq- cr3,ffc10164 <rtems_bdbuf_execute_transfer_request.isra.9+0x1b8>
rtems_bdbuf_unlock_cache ();
if (sc == RTEMS_SUCCESSFUL || sc == RTEMS_UNSATISFIED)
ffc100f8: 41 92 00 10 beq- cr4,ffc10108 <rtems_bdbuf_execute_transfer_request.isra.9+0x15c>
ffc100fc: 2f 99 00 0d cmpwi cr7,r25,13
ffc10100: 41 9e 00 08 beq- cr7,ffc10108 <rtems_bdbuf_execute_transfer_request.isra.9+0x15c>
return sc;
else
return RTEMS_IO_ERROR;
ffc10104: 3b 20 00 1b li r25,27
}
ffc10108: 80 01 00 44 lwz r0,68(r1)
ffc1010c: 7f 23 cb 78 mr r3,r25
ffc10110: 81 81 00 14 lwz r12,20(r1)
ffc10114: 7c 08 03 a6 mtlr r0
ffc10118: 82 c1 00 18 lwz r22,24(r1)
ffc1011c: 82 e1 00 1c lwz r23,28(r1)
ffc10120: 7d 81 81 20 mtcrf 24,r12
ffc10124: 83 01 00 20 lwz r24,32(r1)
ffc10128: 83 21 00 24 lwz r25,36(r1)
ffc1012c: 83 41 00 28 lwz r26,40(r1)
ffc10130: 83 61 00 2c lwz r27,44(r1)
ffc10134: 83 81 00 30 lwz r28,48(r1)
ffc10138: 83 a1 00 34 lwz r29,52(r1)
ffc1013c: 83 c1 00 38 lwz r30,56(r1)
ffc10140: 83 e1 00 3c lwz r31,60(r1)
ffc10144: 38 21 00 40 addi r1,r1,64
ffc10148: 4e 80 00 20 blr
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc1014c: 93 17 00 28 stw r24,40(r23)
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
ffc10150: 7f 43 d3 78 mr r3,r26
ffc10154: 7e e4 bb 78 mr r4,r23
ffc10158: 4b ff b0 21 bl ffc0b178 <_Chain_Append>
ffc1015c: 81 5f 00 10 lwz r10,16(r31)
ffc10160: 4b ff ff 28 b ffc10088 <rtems_bdbuf_execute_transfer_request.isra.9+0xdc>
if (wake_buffer_waiters)
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
if (!cache_locked)
rtems_bdbuf_unlock_cache ();
ffc10164: 4b ff f0 c1 bl ffc0f224 <rtems_bdbuf_unlock_cache>
ffc10168: 4b ff ff 90 b ffc100f8 <rtems_bdbuf_execute_transfer_request.isra.9+0x14c>
if (wake_transfer_waiters)
rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters);
if (wake_buffer_waiters)
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
ffc1016c: 3c 60 00 00 lis r3,0
ffc10170: 38 63 2a 08 addi r3,r3,10760
ffc10174: 38 63 00 78 addi r3,r3,120
ffc10178: 4b ff f4 25 bl ffc0f59c <rtems_bdbuf_wake>
if (!cache_locked)
ffc1017c: 40 8e ff 7c bne+ cr3,ffc100f8 <rtems_bdbuf_execute_transfer_request.isra.9+0x14c>
ffc10180: 4b ff ff e4 b ffc10164 <rtems_bdbuf_execute_transfer_request.isra.9+0x1b8>
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("transfer", bd);
}
if (wake_transfer_waiters)
rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters);
ffc10184: 3c 60 00 00 lis r3,0
ffc10188: 38 63 2a 08 addi r3,r3,10760
ffc1018c: 38 63 00 70 addi r3,r3,112
ffc10190: 4b ff f4 0d bl ffc0f59c <rtems_bdbuf_wake>
ffc10194: 4b ff ff 58 b ffc100ec <rtems_bdbuf_execute_transfer_request.isra.9+0x140>
result = dd->ioctl (dd->phys_dev, RTEMS_BLKIO_REQUEST, req);
if (result == 0)
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_TRANSFER_SYNC);
ffc10198: 38 60 00 02 li r3,2
ffc1019c: 4b ff f1 a1 bl ffc0f33c <rtems_bdbuf_wait_for_event>
sc = req->status;
ffc101a0: 83 3f 00 0c lwz r25,12(r31)
ffc101a4: 4b ff fe 78 b ffc1001c <rtems_bdbuf_execute_transfer_request.isra.9+0x70>
uint32_t transfer_index = 0;
bool wake_transfer_waiters = false;
bool wake_buffer_waiters = false;
if (cache_locked)
rtems_bdbuf_unlock_cache ();
ffc101a8: 90 61 00 08 stw r3,8(r1)
ffc101ac: 90 81 00 0c stw r4,12(r1)
ffc101b0: 4b ff f0 75 bl ffc0f224 <rtems_bdbuf_unlock_cache>
ffc101b4: 80 81 00 0c lwz r4,12(r1)
ffc101b8: 80 61 00 08 lwz r3,8(r1)
ffc101bc: 4b ff fe 38 b ffc0fff4 <rtems_bdbuf_execute_transfer_request.isra.9+0x48>
ffc0f020 <rtems_bdbuf_fatal>:
#define RTEMS_BDBUF_AVL_MAX_HEIGHT (32)
#endif
static void
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)
{
ffc0f020: 94 21 ff f8 stwu r1,-8(r1) <== NOT EXECUTED
ffc0f024: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);
ffc0f028: 54 63 80 1e rlwinm r3,r3,16,0,15 <== NOT EXECUTED
ffc0f02c: 7c 83 1b 78 or r3,r4,r3 <== NOT EXECUTED
#define RTEMS_BDBUF_AVL_MAX_HEIGHT (32)
#endif
static void
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)
{
ffc0f030: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);
ffc0f034: 4b ff ba 7d bl ffc0aab0 <rtems_fatal_error_occurred> <== NOT EXECUTED
ffc113b0 <rtems_bdbuf_get>:
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
ffc113b0: 3d 20 00 00 lis r9,0
rtems_status_code
rtems_bdbuf_get (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
ffc113b4: 94 21 ff d8 stwu r1,-40(r1)
ffc113b8: 7c 08 02 a6 mflr r0
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
ffc113bc: 89 29 2a 90 lbz r9,10896(r9)
rtems_status_code
rtems_bdbuf_get (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
ffc113c0: 90 01 00 2c stw r0,44(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
ffc113c4: 38 00 00 00 li r0,0
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
ffc113c8: 2f 89 00 00 cmpwi cr7,r9,0
rtems_status_code
rtems_bdbuf_get (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
ffc113cc: 93 81 00 18 stw r28,24(r1)
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
return RTEMS_NOT_CONFIGURED;
ffc113d0: 3b 80 00 16 li r28,22
rtems_status_code
rtems_bdbuf_get (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
ffc113d4: 93 a1 00 1c stw r29,28(r1)
ffc113d8: 7c dd 33 78 mr r29,r6
ffc113dc: 93 c1 00 20 stw r30,32(r1)
ffc113e0: 7c 7e 1b 78 mr r30,r3
ffc113e4: 93 e1 00 24 stw r31,36(r1)
ffc113e8: 7c 9f 23 78 mr r31,r4
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
ffc113ec: 90 01 00 10 stw r0,16(r1)
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block = 0;
ffc113f0: 90 01 00 0c stw r0,12(r1)
size_t bds_per_group = 0;
ffc113f4: 90 01 00 08 stw r0,8(r1)
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
ffc113f8: 40 9e 00 28 bne- cr7,ffc11420 <rtems_bdbuf_get+0x70> <== ALWAYS TAKEN
rtems_bdbuf_release_disk (dd);
*bd_ptr = bd;
return RTEMS_SUCCESSFUL;
}
ffc113fc: 80 01 00 2c lwz r0,44(r1) <== NOT EXECUTED
ffc11400: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc11404: 83 a1 00 1c lwz r29,28(r1) <== NOT EXECUTED
ffc11408: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc1140c: 83 81 00 18 lwz r28,24(r1) <== NOT EXECUTED
ffc11410: 83 c1 00 20 lwz r30,32(r1) <== NOT EXECUTED
ffc11414: 83 e1 00 24 lwz r31,36(r1) <== NOT EXECUTED
ffc11418: 38 21 00 28 addi r1,r1,40 <== NOT EXECUTED
ffc1141c: 4e 80 00 20 blr <== NOT EXECUTED
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
ffc11420: 38 c1 00 10 addi r6,r1,16
ffc11424: 38 e1 00 0c addi r7,r1,12
ffc11428: 39 01 00 08 addi r8,r1,8
ffc1142c: 4b ff e2 d1 bl ffc0f6fc <rtems_bdbuf_obtain_disk.part.8>
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block = 0;
size_t bds_per_group = 0;
sc = rtems_bdbuf_obtain_disk (dev, block, &dd, &media_block, &bds_per_group);
if (sc != RTEMS_SUCCESSFUL)
ffc11430: 7c 7c 1b 79 mr. r28,r3
ffc11434: 40 a2 ff c8 bne- ffc113fc <rtems_bdbuf_get+0x4c> <== NEVER TAKEN
return sc;
rtems_bdbuf_lock_cache ();
ffc11438: 4b ff db 61 bl ffc0ef98 <rtems_bdbuf_lock_cache>
*/
if (rtems_bdbuf_tracer)
printf ("bdbuf:get: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block, block, (unsigned) dev);
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
ffc1143c: 80 a1 00 0c lwz r5,12(r1)
ffc11440: 80 c1 00 08 lwz r6,8(r1)
ffc11444: 7f c3 f3 78 mr r3,r30
ffc11448: 7f e4 fb 78 mr r4,r31
ffc1144c: 4b ff f8 c5 bl ffc10d10 <rtems_bdbuf_get_buffer_for_access>
switch (bd->state)
ffc11450: 80 03 00 28 lwz r0,40(r3)
*/
if (rtems_bdbuf_tracer)
printf ("bdbuf:get: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block, block, (unsigned) dev);
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
ffc11454: 7c 7e 1b 78 mr r30,r3
switch (bd->state)
ffc11458: 2f 80 00 02 cmpwi cr7,r0,2
ffc1145c: 41 9e 00 60 beq- cr7,ffc114bc <rtems_bdbuf_get+0x10c>
ffc11460: 2f 80 00 07 cmpwi cr7,r0,7
ffc11464: 41 9e 00 1c beq- cr7,ffc11480 <rtems_bdbuf_get+0xd0>
ffc11468: 2f 80 00 01 cmpwi cr7,r0,1
ffc1146c: 41 9e 00 5c beq- cr7,ffc114c8 <rtems_bdbuf_get+0x118> <== ALWAYS TAKEN
* so just gets the block to fill.
*/
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_2);
ffc11470: 3c 80 42 00 lis r4,16896 <== NOT EXECUTED
ffc11474: 80 63 00 28 lwz r3,40(r3) <== NOT EXECUTED
ffc11478: 60 84 00 1e ori r4,r4,30 <== NOT EXECUTED
ffc1147c: 4b ff db a5 bl ffc0f020 <rtems_bdbuf_fatal> <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc11480: 38 00 00 04 li r0,4
ffc11484: 90 03 00 28 stw r0,40(r3)
{
rtems_bdbuf_show_users ("get", bd);
rtems_bdbuf_show_usage ();
}
rtems_bdbuf_unlock_cache ();
ffc11488: 4b ff dd 9d bl ffc0f224 <rtems_bdbuf_unlock_cache>
rtems_bdbuf_release_disk (dd);
ffc1148c: 80 61 00 10 lwz r3,16(r1)
ffc11490: 4b ff de 0d bl ffc0f29c <rtems_bdbuf_release_disk>
*bd_ptr = bd;
return RTEMS_SUCCESSFUL;
}
ffc11494: 80 01 00 2c lwz r0,44(r1)
rtems_bdbuf_unlock_cache ();
rtems_bdbuf_release_disk (dd);
*bd_ptr = bd;
ffc11498: 93 dd 00 00 stw r30,0(r29)
return RTEMS_SUCCESSFUL;
}
ffc1149c: 7f 83 e3 78 mr r3,r28
ffc114a0: 7c 08 03 a6 mtlr r0
ffc114a4: 83 81 00 18 lwz r28,24(r1)
ffc114a8: 83 a1 00 1c lwz r29,28(r1)
ffc114ac: 83 c1 00 20 lwz r30,32(r1)
ffc114b0: 83 e1 00 24 lwz r31,36(r1)
ffc114b4: 38 21 00 28 addi r1,r1,40
ffc114b8: 4e 80 00 20 blr
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc114bc: 38 00 00 03 li r0,3
ffc114c0: 90 03 00 28 stw r0,40(r3)
ffc114c4: 4b ff ff c4 b ffc11488 <rtems_bdbuf_get+0xd8>
ffc114c8: 38 00 00 05 li r0,5
ffc114cc: 90 03 00 28 stw r0,40(r3)
ffc114d0: 4b ff ff b8 b ffc11488 <rtems_bdbuf_get+0xd8>
ffc10d10 <rtems_bdbuf_get_buffer_for_access>:
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_access (dev_t dev,
rtems_blkdev_bnum block,
size_t bds_per_group)
{
ffc10d10: 94 21 ff b8 stwu r1,-72(r1)
ffc10d14: 7c 08 02 a6 mflr r0
ffc10d18: 93 81 00 38 stw r28,56(r1)
ffc10d1c: 3f 80 00 00 lis r28,0
ffc10d20: 3b 9c 2a 08 addi r28,r28,10760
ffc10d24: 93 61 00 34 stw r27,52(r1)
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
ffc10d28: 3f 60 ff c2 lis r27,-62
ffc10d2c: 3b 7b ef ac addi r27,r27,-4180
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_access (dev_t dev,
rtems_blkdev_bnum block,
size_t bds_per_group)
{
ffc10d30: 90 01 00 4c stw r0,76(r1)
ffc10d34: 92 21 00 0c stw r17,12(r1)
ffc10d38: 92 41 00 10 stw r18,16(r1)
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_tail(
const Chain_Control *the_chain
)
{
return &the_chain->Tail.Node;
ffc10d3c: 3a 5c 00 54 addi r18,r28,84
ffc10d40: 92 61 00 14 stw r19,20(r1)
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
break;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
ffc10d44: 3a 7c 00 70 addi r19,r28,112
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_access (dev_t dev,
rtems_blkdev_bnum block,
size_t bds_per_group)
{
ffc10d48: 92 81 00 18 stw r20,24(r1)
}
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
ffc10d4c: 3a 9c 00 68 addi r20,r28,104
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_access (dev_t dev,
rtems_blkdev_bnum block,
size_t bds_per_group)
{
ffc10d50: 92 a1 00 1c stw r21,28(r1)
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc10d54: 3a a0 00 08 li r21,8
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_access (dev_t dev,
rtems_blkdev_bnum block,
size_t bds_per_group)
{
ffc10d58: 92 c1 00 20 stw r22,32(r1)
static void
rtems_bdbuf_request_sync_for_modified_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_extract (&bd->link);
rtems_chain_append (&bdbuf_cache.sync, &bd->link);
ffc10d5c: 3a dc 00 5c addi r22,r28,92
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_access (dev_t dev,
rtems_blkdev_bnum block,
size_t bds_per_group)
{
ffc10d60: 92 e1 00 24 stw r23,36(r1)
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc10d64: 3a e0 00 00 li r23,0
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_access (dev_t dev,
rtems_blkdev_bnum block,
size_t bds_per_group)
{
ffc10d68: 93 01 00 28 stw r24,40(r1)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head(
Chain_Control *the_chain
)
{
return &the_chain->Head.Node;
ffc10d6c: 3b 1c 00 44 addi r24,r28,68
ffc10d70: 93 21 00 2c stw r25,44(r1)
{
if (rtems_bdbuf_wait_for_recycle (bd))
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
ffc10d74: 3b 3c 00 78 addi r25,r28,120
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_access (dev_t dev,
rtems_blkdev_bnum block,
size_t bds_per_group)
{
ffc10d78: 93 41 00 30 stw r26,48(r1)
ffc10d7c: 7c da 33 78 mr r26,r6
ffc10d80: 93 a1 00 3c stw r29,60(r1)
ffc10d84: 7c bd 2b 78 mr r29,r5
ffc10d88: 93 c1 00 40 stw r30,64(r1)
ffc10d8c: 7c 9e 23 78 mr r30,r4
ffc10d90: 93 e1 00 44 stw r31,68(r1)
ffc10d94: 7c 7f 1b 78 mr r31,r3
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dev, block);
ffc10d98: 82 3c 00 40 lwz r17,64(r28)
dev_t dev,
rtems_blkdev_bnum block)
{
rtems_bdbuf_buffer* p = *root;
while ((p != NULL) && ((p->dev != dev) || (p->block != block)))
ffc10d9c: 2f 91 00 00 cmpwi cr7,r17,0
ffc10da0: 41 9e 00 28 beq- cr7,ffc10dc8 <rtems_bdbuf_get_buffer_for_access+0xb8>
ffc10da4: 80 11 00 18 lwz r0,24(r17)
ffc10da8: 81 31 00 1c lwz r9,28(r17)
ffc10dac: 7f 9f 00 00 cmpw cr7,r31,r0
ffc10db0: 41 9e 00 74 beq- cr7,ffc10e24 <rtems_bdbuf_get_buffer_for_access+0x114>
{
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
ffc10db4: 7f 1f 00 40 cmplw cr6,r31,r0
ffc10db8: 40 99 00 58 ble- cr6,ffc10e10 <rtems_bdbuf_get_buffer_for_access+0x100>
{
p = p->avl.right;
ffc10dbc: 82 31 00 0c lwz r17,12(r17)
dev_t dev,
rtems_blkdev_bnum block)
{
rtems_bdbuf_buffer* p = *root;
while ((p != NULL) && ((p->dev != dev) || (p->block != block)))
ffc10dc0: 2f 91 00 00 cmpwi cr7,r17,0
ffc10dc4: 40 9e ff e0 bne+ cr7,ffc10da4 <rtems_bdbuf_get_buffer_for_access+0x94>
bd = NULL;
}
}
else
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dev, block, bds_per_group);
ffc10dc8: 7f e3 fb 78 mr r3,r31
ffc10dcc: 7f c4 f3 78 mr r4,r30
ffc10dd0: 7f a5 eb 78 mr r5,r29
ffc10dd4: 7f 46 d3 78 mr r6,r26
ffc10dd8: 4b ff fa d9 bl ffc108b0 <rtems_bdbuf_get_buffer_from_lru_list>
if (bd == NULL)
ffc10ddc: 7c 71 1b 79 mr. r17,r3
ffc10de0: 41 82 01 2c beq- ffc10f0c <rtems_bdbuf_get_buffer_for_access+0x1fc>
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
ffc10de4: 3f e0 ff c2 lis r31,-62
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
break;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
ffc10de8: 3b dc 00 70 addi r30,r28,112
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
ffc10dec: 3b ff ef d8 addi r31,r31,-4136
return;
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
ffc10df0: 3b 9c 00 68 addi r28,r28,104
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
ffc10df4: 80 11 00 28 lwz r0,40(r17)
ffc10df8: 2b 80 00 0a cmplwi cr7,r0,10
ffc10dfc: 40 9d 00 fc ble- cr7,ffc10ef8 <rtems_bdbuf_get_buffer_for_access+0x1e8><== ALWAYS TAKEN
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_7);
ffc10e00: 3c 80 42 00 lis r4,16896 <== NOT EXECUTED
ffc10e04: 80 71 00 28 lwz r3,40(r17) <== NOT EXECUTED
ffc10e08: 60 84 00 05 ori r4,r4,5 <== NOT EXECUTED
ffc10e0c: 4b ff e2 15 bl ffc0f020 <rtems_bdbuf_fatal> <== NOT EXECUTED
{
rtems_bdbuf_buffer* p = *root;
while ((p != NULL) && ((p->dev != dev) || (p->block != block)))
{
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
ffc10e10: 40 9e 00 0c bne- cr7,ffc10e1c <rtems_bdbuf_get_buffer_for_access+0x10c><== ALWAYS TAKEN
ffc10e14: 7f 9e 48 40 cmplw cr7,r30,r9 <== NOT EXECUTED
ffc10e18: 41 9d ff a4 bgt+ cr7,ffc10dbc <rtems_bdbuf_get_buffer_for_access+0xac><== NOT EXECUTED
{
p = p->avl.right;
}
else
{
p = p->avl.left;
ffc10e1c: 82 31 00 08 lwz r17,8(r17)
ffc10e20: 4b ff ff a0 b ffc10dc0 <rtems_bdbuf_get_buffer_for_access+0xb0>
dev_t dev,
rtems_blkdev_bnum block)
{
rtems_bdbuf_buffer* p = *root;
while ((p != NULL) && ((p->dev != dev) || (p->block != block)))
ffc10e24: 7f 1e 48 00 cmpw cr6,r30,r9
ffc10e28: 40 9a ff 8c bne+ cr6,ffc10db4 <rtems_bdbuf_get_buffer_for_access+0xa4><== NEVER TAKEN
ffc10e2c: 80 11 00 20 lwz r0,32(r17)
ffc10e30: 7f 9d 00 00 cmpw cr7,r29,r0
ffc10e34: 41 9e 00 14 beq- cr7,ffc10e48 <rtems_bdbuf_get_buffer_for_access+0x138>
{
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
ffc10e38: 7f 9d 00 40 cmplw cr7,r29,r0
ffc10e3c: 41 bd ff 80 bgt- cr7,ffc10dbc <rtems_bdbuf_get_buffer_for_access+0xac>
{
p = p->avl.right;
}
else
{
p = p->avl.left;
ffc10e40: 82 31 00 08 lwz r17,8(r17)
ffc10e44: 4b ff ff 7c b ffc10dc0 <rtems_bdbuf_get_buffer_for_access+0xb0>
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dev, block);
if (bd != NULL)
{
if (bd->group->bds_per_group != bds_per_group)
ffc10e48: 81 31 00 30 lwz r9,48(r17)
ffc10e4c: 80 09 00 08 lwz r0,8(r9)
ffc10e50: 7f 80 d0 00 cmpw cr7,r0,r26
ffc10e54: 41 be ff 90 beq- cr7,ffc10de4 <rtems_bdbuf_get_buffer_for_access+0xd4>
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
ffc10e58: 80 11 00 28 lwz r0,40(r17)
ffc10e5c: 2b 80 00 0a cmplwi cr7,r0,10
ffc10e60: 40 9d 00 14 ble- cr7,ffc10e74 <rtems_bdbuf_get_buffer_for_access+0x164><== ALWAYS TAKEN
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_8);
ffc10e64: 3c 80 42 00 lis r4,16896 <== NOT EXECUTED
ffc10e68: 80 71 00 28 lwz r3,40(r17) <== NOT EXECUTED
ffc10e6c: 60 84 00 06 ori r4,r4,6 <== NOT EXECUTED
ffc10e70: 4b ff e1 b1 bl ffc0f020 <rtems_bdbuf_fatal> <== NOT EXECUTED
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
ffc10e74: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc10e78: 7c 1b 00 2e lwzx r0,r27,r0
ffc10e7c: 7c 00 da 14 add r0,r0,r27
ffc10e80: 7c 09 03 a6 mtctr r0
ffc10e84: 4e 80 04 20 bctr
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc10e88: 92 b1 00 28 stw r21,40(r17) <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
ffc10e8c: 7e 23 8b 78 mr r3,r17 <== NOT EXECUTED
ffc10e90: 4b ff a3 19 bl ffc0b1a8 <_Chain_Extract> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
ffc10e94: 7e c3 b3 78 mr r3,r22 <== NOT EXECUTED
ffc10e98: 7e 24 8b 78 mr r4,r17 <== NOT EXECUTED
ffc10e9c: 4b ff a2 dd bl ffc0b178 <_Chain_Append> <== NOT EXECUTED
rtems_bdbuf_request_sync_for_modified_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_extract (&bd->link);
rtems_chain_append (&bdbuf_cache.sync, &bd->link);
rtems_bdbuf_wake_swapper ();
ffc10ea0: 4b ff e4 31 bl ffc0f2d0 <rtems_bdbuf_wake_swapper> <== NOT EXECUTED
ffc10ea4: 4b ff ff b4 b ffc10e58 <rtems_bdbuf_get_buffer_for_access+0x148><== NOT EXECUTED
}
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
ffc10ea8: 7e 23 8b 78 mr r3,r17
ffc10eac: 7e 84 a3 78 mr r4,r20
ffc10eb0: 4b ff e6 15 bl ffc0f4c4 <rtems_bdbuf_wait>
ffc10eb4: 4b ff ff a4 b ffc10e58 <rtems_bdbuf_get_buffer_for_access+0x148>
case RTEMS_BDBUF_STATE_MODIFIED:
rtems_bdbuf_request_sync_for_modified_buffer (bd);
break;
case RTEMS_BDBUF_STATE_CACHED:
case RTEMS_BDBUF_STATE_EMPTY:
if (bd->waiters == 0)
ffc10eb8: 80 11 00 2c lwz r0,44(r17)
ffc10ebc: 2f 80 00 00 cmpwi cr7,r0,0
ffc10ec0: 40 9e 00 5c bne- cr7,ffc10f1c <rtems_bdbuf_get_buffer_for_access+0x20c><== ALWAYS TAKEN
{
if (bd->group->bds_per_group != bds_per_group)
{
if (rtems_bdbuf_wait_for_recycle (bd))
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
ffc10ec4: 7e 23 8b 78 mr r3,r17 <== NOT EXECUTED
ffc10ec8: 4b ff ed b1 bl ffc0fc78 <rtems_bdbuf_remove_from_tree_and_lru_list><== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc10ecc: 92 f1 00 28 stw r23,40(r17) <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
ffc10ed0: 7f 03 c3 78 mr r3,r24 <== NOT EXECUTED
ffc10ed4: 7e 24 8b 78 mr r4,r17 <== NOT EXECUTED
ffc10ed8: 48 00 46 6d bl ffc15544 <_Chain_Insert> <== NOT EXECUTED
{
if (rtems_bdbuf_wait_for_recycle (bd))
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
ffc10edc: 7f 23 cb 78 mr r3,r25 <== NOT EXECUTED
ffc10ee0: 4b ff e6 bd bl ffc0f59c <rtems_bdbuf_wake> <== NOT EXECUTED
ffc10ee4: 4b ff fe b4 b ffc10d98 <rtems_bdbuf_get_buffer_for_access+0x88><== NOT EXECUTED
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
break;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
ffc10ee8: 7e 23 8b 78 mr r3,r17 <== NOT EXECUTED
ffc10eec: 7e 64 9b 78 mr r4,r19 <== NOT EXECUTED
ffc10ef0: 4b ff e5 d5 bl ffc0f4c4 <rtems_bdbuf_wait> <== NOT EXECUTED
ffc10ef4: 4b ff ff 64 b ffc10e58 <rtems_bdbuf_get_buffer_for_access+0x148><== NOT EXECUTED
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
ffc10ef8: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc10efc: 7c 1f 00 2e lwzx r0,r31,r0
ffc10f00: 7c 00 fa 14 add r0,r0,r31
ffc10f04: 7c 09 03 a6 mtctr r0
ffc10f08: 4e 80 04 20 bctr
}
static void
rtems_bdbuf_wait_for_buffer (void)
{
if (!rtems_chain_is_empty (&bdbuf_cache.modified))
ffc10f0c: 80 1c 00 50 lwz r0,80(r28)
ffc10f10: 7f 80 90 00 cmpw cr7,r0,r18
ffc10f14: 41 9e 00 08 beq- cr7,ffc10f1c <rtems_bdbuf_get_buffer_for_access+0x20c>
rtems_bdbuf_wake_swapper ();
ffc10f18: 4b ff e3 b9 bl ffc0f2d0 <rtems_bdbuf_wake_swapper>
rtems_bdbuf_anonymous_wait (&bdbuf_cache.buffer_waiters);
ffc10f1c: 7f 23 cb 78 mr r3,r25
ffc10f20: 4b ff e5 0d bl ffc0f42c <rtems_bdbuf_anonymous_wait>
ffc10f24: 4b ff fe 74 b ffc10d98 <rtems_bdbuf_get_buffer_for_access+0x88>
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
ffc10f28: 81 31 00 30 lwz r9,48(r17)
ffc10f2c: 80 09 00 0c lwz r0,12(r9)
ffc10f30: 30 00 ff ff addic r0,r0,-1
ffc10f34: 90 09 00 0c stw r0,12(r9)
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
ffc10f38: 7e 23 8b 78 mr r3,r17
ffc10f3c: 4b ff a2 6d bl ffc0b1a8 <_Chain_Extract>
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
ffc10f40: 81 31 00 30 lwz r9,48(r17)
rtems_bdbuf_wait_for_access (bd);
rtems_bdbuf_group_obtain (bd);
return bd;
}
ffc10f44: 7e 23 8b 78 mr r3,r17
ffc10f48: 82 41 00 10 lwz r18,16(r1)
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
ffc10f4c: 81 69 00 0c lwz r11,12(r9)
rtems_bdbuf_wait_for_access (bd);
rtems_bdbuf_group_obtain (bd);
return bd;
}
ffc10f50: 82 21 00 0c lwz r17,12(r1)
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
ffc10f54: 38 0b 00 01 addi r0,r11,1
rtems_bdbuf_wait_for_access (bd);
rtems_bdbuf_group_obtain (bd);
return bd;
}
ffc10f58: 82 61 00 14 lwz r19,20(r1)
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
ffc10f5c: 90 09 00 0c stw r0,12(r9)
rtems_bdbuf_wait_for_access (bd);
rtems_bdbuf_group_obtain (bd);
return bd;
}
ffc10f60: 80 01 00 4c lwz r0,76(r1)
ffc10f64: 82 81 00 18 lwz r20,24(r1)
ffc10f68: 7c 08 03 a6 mtlr r0
ffc10f6c: 82 a1 00 1c lwz r21,28(r1)
ffc10f70: 82 c1 00 20 lwz r22,32(r1)
ffc10f74: 82 e1 00 24 lwz r23,36(r1)
ffc10f78: 83 01 00 28 lwz r24,40(r1)
ffc10f7c: 83 21 00 2c lwz r25,44(r1)
ffc10f80: 83 41 00 30 lwz r26,48(r1)
ffc10f84: 83 61 00 34 lwz r27,52(r1)
ffc10f88: 83 81 00 38 lwz r28,56(r1)
ffc10f8c: 83 a1 00 3c lwz r29,60(r1)
ffc10f90: 83 c1 00 40 lwz r30,64(r1)
ffc10f94: 83 e1 00 44 lwz r31,68(r1)
ffc10f98: 38 21 00 48 addi r1,r1,72
ffc10f9c: 4e 80 00 20 blr
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
break;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
ffc10fa0: 7e 23 8b 78 mr r3,r17
ffc10fa4: 7f c4 f3 78 mr r4,r30
ffc10fa8: 4b ff e5 1d bl ffc0f4c4 <rtems_bdbuf_wait>
ffc10fac: 4b ff fe 48 b ffc10df4 <rtems_bdbuf_get_buffer_for_access+0xe4>
return;
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
ffc10fb0: 7e 23 8b 78 mr r3,r17
ffc10fb4: 7f 84 e3 78 mr r4,r28
ffc10fb8: 4b ff e5 0d bl ffc0f4c4 <rtems_bdbuf_wait>
ffc10fbc: 4b ff fe 38 b ffc10df4 <rtems_bdbuf_get_buffer_for_access+0xe4>
ffc108b0 <rtems_bdbuf_get_buffer_from_lru_list>:
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_from_lru_list (dev_t dev,
rtems_blkdev_bnum block,
size_t bds_per_group)
{
ffc108b0: 94 21 ff 40 stwu r1,-192(r1)
ffc108b4: 7c 08 02 a6 mflr r0
ffc108b8: 93 81 00 b0 stw r28,176(r1)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc108bc: 3f 80 00 00 lis r28,0
ffc108c0: 3b 9c 2a 08 addi r28,r28,10760
ffc108c4: 93 e1 00 bc stw r31,188(r1)
ffc108c8: 83 fc 00 44 lwz r31,68(r28)
ffc108cc: 93 a1 00 b4 stw r29,180(r1)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return &the_chain->Tail.Node;
ffc108d0: 3b bc 00 48 addi r29,r28,72
rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);
while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))
ffc108d4: 7f 9f e8 00 cmpw cr7,r31,r29
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_from_lru_list (dev_t dev,
rtems_blkdev_bnum block,
size_t bds_per_group)
{
ffc108d8: 92 61 00 8c stw r19,140(r1)
ffc108dc: 7c d3 33 78 mr r19,r6
ffc108e0: 93 41 00 a8 stw r26,168(r1)
ffc108e4: 7c ba 2b 78 mr r26,r5
ffc108e8: 93 61 00 ac stw r27,172(r1)
ffc108ec: 7c 9b 23 78 mr r27,r4
ffc108f0: 93 c1 00 b8 stw r30,184(r1)
ffc108f4: 7c 7e 1b 78 mr r30,r3
ffc108f8: 90 01 00 c4 stw r0,196(r1)
ffc108fc: 92 41 00 88 stw r18,136(r1)
ffc10900: 92 81 00 90 stw r20,144(r1)
ffc10904: 92 a1 00 94 stw r21,148(r1)
ffc10908: 92 c1 00 98 stw r22,152(r1)
ffc1090c: 92 e1 00 9c stw r23,156(r1)
ffc10910: 93 01 00 a0 stw r24,160(r1)
ffc10914: 93 21 00 a4 stw r25,164(r1)
rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);
while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))
ffc10918: 41 9e 00 e0 beq- cr7,ffc109f8 <rtems_bdbuf_get_buffer_from_lru_list+0x148>
ffc1091c: 3a 9c 00 44 addi r20,r28,68
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc10920: 3a a0 00 00 li r21,0
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
if (b > 1)
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
ffc10924: 3a 5c 00 78 addi r18,r28,120
bd->group->bds_per_group, bds_per_group);
/*
* If nobody waits for this BD, we may recycle it.
*/
if (bd->waiters == 0)
ffc10928: 80 1f 00 2c lwz r0,44(r31)
ffc1092c: 2f 80 00 00 cmpwi cr7,r0,0
ffc10930: 40 9e 00 bc bne- cr7,ffc109ec <rtems_bdbuf_get_buffer_from_lru_list+0x13c>
{
if (bd->group->bds_per_group == bds_per_group)
ffc10934: 82 ff 00 30 lwz r23,48(r31)
ffc10938: 80 17 00 08 lwz r0,8(r23)
ffc1093c: 7f 80 98 00 cmpw cr7,r0,r19
ffc10940: 41 9e 01 08 beq- cr7,ffc10a48 <rtems_bdbuf_get_buffer_from_lru_list+0x198>
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
empty_bd = bd;
}
else if (bd->group->users == 0)
ffc10944: 81 37 00 0c lwz r9,12(r23)
ffc10948: 2f 89 00 00 cmpwi cr7,r9,0
ffc1094c: 40 9e 00 a0 bne- cr7,ffc109ec <rtems_bdbuf_get_buffer_from_lru_list+0x13c>
group - bdbuf_cache.groups, group->bds_per_group,
new_bds_per_group);
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
for (b = 0, bd = group->bdbuf;
ffc10950: 2f 80 00 00 cmpwi cr7,r0,0
if (rtems_bdbuf_tracer)
printf ("bdbuf:realloc: %tu: %zd -> %zd\n",
group - bdbuf_cache.groups, group->bds_per_group,
new_bds_per_group);
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
ffc10954: 82 dc 00 20 lwz r22,32(r28)
for (b = 0, bd = group->bdbuf;
ffc10958: 83 37 00 10 lwz r25,16(r23)
ffc1095c: 41 9e 00 30 beq- cr7,ffc1098c <rtems_bdbuf_get_buffer_from_lru_list+0xdc><== NEVER TAKEN
if (rtems_bdbuf_tracer)
printf ("bdbuf:realloc: %tu: %zd -> %zd\n",
group - bdbuf_cache.groups, group->bds_per_group,
new_bds_per_group);
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
ffc10960: 7e d6 03 96 divwu r22,r22,r0
for (b = 0, bd = group->bdbuf;
ffc10964: 3b 00 00 00 li r24,0
ffc10968: 56 d6 30 32 rlwinm r22,r22,6,0,25
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
ffc1096c: 7f 23 cb 78 mr r3,r25
ffc10970: 4b ff f3 09 bl ffc0fc78 <rtems_bdbuf_remove_from_tree_and_lru_list>
group - bdbuf_cache.groups, group->bds_per_group,
new_bds_per_group);
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
for (b = 0, bd = group->bdbuf;
ffc10974: 80 17 00 08 lwz r0,8(r23)
b < group->bds_per_group;
b++, bd += bufs_per_bd)
ffc10978: 3b 18 00 01 addi r24,r24,1
group - bdbuf_cache.groups, group->bds_per_group,
new_bds_per_group);
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
for (b = 0, bd = group->bdbuf;
ffc1097c: 7f 98 00 40 cmplw cr7,r24,r0
b < group->bds_per_group;
b++, bd += bufs_per_bd)
ffc10980: 7f 39 b2 14 add r25,r25,r22
group - bdbuf_cache.groups, group->bds_per_group,
new_bds_per_group);
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
for (b = 0, bd = group->bdbuf;
ffc10984: 41 9c ff e8 blt+ cr7,ffc1096c <rtems_bdbuf_get_buffer_from_lru_list+0xbc>
ffc10988: 83 37 00 10 lwz r25,16(r23)
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
group->bds_per_group = new_bds_per_group;
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
for (b = 1, bd = group->bdbuf + bufs_per_bd;
ffc1098c: 2b 93 00 01 cmplwi cr7,r19,1
for (b = 0, bd = group->bdbuf;
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
group->bds_per_group = new_bds_per_group;
ffc10990: 92 77 00 08 stw r19,8(r23)
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
ffc10994: 82 dc 00 20 lwz r22,32(r28)
for (b = 1, bd = group->bdbuf + bufs_per_bd;
ffc10998: 40 9d 00 4c ble- cr7,ffc109e4 <rtems_bdbuf_get_buffer_from_lru_list+0x134>
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
group->bds_per_group = new_bds_per_group;
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
ffc1099c: 7e d6 9b 96 divwu r22,r22,r19
for (b = 1, bd = group->bdbuf + bufs_per_bd;
ffc109a0: 56 d6 30 32 rlwinm r22,r22,6,0,25
ffc109a4: 7f 39 b2 14 add r25,r25,r22
ffc109a8: 3b 00 00 01 li r24,1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc109ac: 92 b9 00 28 stw r21,40(r25)
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
ffc109b0: 7f 24 cb 78 mr r4,r25
ffc109b4: 7e 83 a3 78 mr r3,r20
ffc109b8: 48 00 4b 8d bl ffc15544 <_Chain_Insert>
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
group->bds_per_group = new_bds_per_group;
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
for (b = 1, bd = group->bdbuf + bufs_per_bd;
ffc109bc: 80 17 00 08 lwz r0,8(r23)
b < group->bds_per_group;
b++, bd += bufs_per_bd)
ffc109c0: 3b 18 00 01 addi r24,r24,1
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
group->bds_per_group = new_bds_per_group;
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
for (b = 1, bd = group->bdbuf + bufs_per_bd;
ffc109c4: 7f 98 00 40 cmplw cr7,r24,r0
b < group->bds_per_group;
b++, bd += bufs_per_bd)
ffc109c8: 7f 39 b2 14 add r25,r25,r22
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
group->bds_per_group = new_bds_per_group;
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
for (b = 1, bd = group->bdbuf + bufs_per_bd;
ffc109cc: 41 9c ff e0 blt+ cr7,ffc109ac <rtems_bdbuf_get_buffer_from_lru_list+0xfc><== NEVER TAKEN
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
if (b > 1)
ffc109d0: 2b 98 00 01 cmplwi cr7,r24,1
ffc109d4: 40 9d 00 0c ble- cr7,ffc109e0 <rtems_bdbuf_get_buffer_from_lru_list+0x130><== NEVER TAKEN
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
ffc109d8: 7e 43 93 78 mr r3,r18
ffc109dc: 4b ff eb c1 bl ffc0f59c <rtems_bdbuf_wake>
ffc109e0: 83 37 00 10 lwz r25,16(r23)
}
else if (bd->group->users == 0)
empty_bd = rtems_bdbuf_group_realloc (bd->group, bds_per_group);
}
if (empty_bd != NULL)
ffc109e4: 2f 99 00 00 cmpwi cr7,r25,0
ffc109e8: 40 9e 00 74 bne- cr7,ffc10a5c <rtems_bdbuf_get_buffer_from_lru_list+0x1ac><== ALWAYS TAKEN
rtems_bdbuf_purge_major (rtems_device_major_number major)
{
dev_t dev = rtems_filesystem_make_dev_t (major, 0);
rtems_bdbuf_purge (rtems_bdbuf_purge_compare_major, dev);
}
ffc109ec: 83 ff 00 00 lwz r31,0(r31)
rtems_blkdev_bnum block,
size_t bds_per_group)
{
rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);
while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))
ffc109f0: 7f 9f e8 00 cmpw cr7,r31,r29
ffc109f4: 40 9e ff 34 bne+ cr7,ffc10928 <rtems_bdbuf_get_buffer_from_lru_list+0x78>
}
node = rtems_chain_next (node);
}
return NULL;
ffc109f8: 3b 20 00 00 li r25,0
}
ffc109fc: 80 01 00 c4 lwz r0,196(r1)
ffc10a00: 7f 23 cb 78 mr r3,r25
ffc10a04: 82 41 00 88 lwz r18,136(r1)
ffc10a08: 7c 08 03 a6 mtlr r0
ffc10a0c: 82 61 00 8c lwz r19,140(r1)
ffc10a10: 82 81 00 90 lwz r20,144(r1)
ffc10a14: 82 a1 00 94 lwz r21,148(r1)
ffc10a18: 82 c1 00 98 lwz r22,152(r1)
ffc10a1c: 82 e1 00 9c lwz r23,156(r1)
ffc10a20: 83 01 00 a0 lwz r24,160(r1)
ffc10a24: 83 21 00 a4 lwz r25,164(r1)
ffc10a28: 83 41 00 a8 lwz r26,168(r1)
ffc10a2c: 83 61 00 ac lwz r27,172(r1)
ffc10a30: 83 81 00 b0 lwz r28,176(r1)
ffc10a34: 83 a1 00 b4 lwz r29,180(r1)
ffc10a38: 83 c1 00 b8 lwz r30,184(r1)
ffc10a3c: 83 e1 00 bc lwz r31,188(r1)
ffc10a40: 38 21 00 c0 addi r1,r1,192
ffc10a44: 4e 80 00 20 blr
*/
if (bd->waiters == 0)
{
if (bd->group->bds_per_group == bds_per_group)
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
ffc10a48: 7f e3 fb 78 mr r3,r31
ffc10a4c: 7f f9 fb 78 mr r25,r31
ffc10a50: 4b ff f2 29 bl ffc0fc78 <rtems_bdbuf_remove_from_tree_and_lru_list>
}
else if (bd->group->users == 0)
empty_bd = rtems_bdbuf_group_realloc (bd->group, bds_per_group);
}
if (empty_bd != NULL)
ffc10a54: 2f 99 00 00 cmpwi cr7,r25,0
ffc10a58: 41 9e ff 94 beq+ cr7,ffc109ec <rtems_bdbuf_get_buffer_from_lru_list+0x13c><== NEVER TAKEN
dev_t dev,
rtems_blkdev_bnum block)
{
bd->dev = dev;
bd->block = block;
bd->avl.left = NULL;
ffc10a5c: 38 00 00 00 li r0,0
ffc10a60: 90 19 00 08 stw r0,8(r25)
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
ffc10a64: 38 c1 00 08 addi r6,r1,8
ffc10a68: 7c cb 33 78 mr r11,r6
rtems_blkdev_bnum block)
{
bd->dev = dev;
bd->block = block;
bd->avl.left = NULL;
bd->avl.right = NULL;
ffc10a6c: 90 19 00 0c stw r0,12(r25)
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
{
p->avl.cache = 1;
ffc10a70: 38 e0 00 01 li r7,1
break;
}
}
else if ((p->dev != dev) || (p->block != block))
{
p->avl.cache = -1;
ffc10a74: 38 a0 ff ff li r5,-1
rtems_bdbuf_buffer* node)
{
dev_t dev = node->dev;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
ffc10a78: 81 3c 00 40 lwz r9,64(r28)
static void
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,
dev_t dev,
rtems_blkdev_bnum block)
{
bd->dev = dev;
ffc10a7c: 93 d9 00 18 stw r30,24(r25)
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
ffc10a80: 2f 89 00 00 cmpwi cr7,r9,0
static void
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,
dev_t dev,
rtems_blkdev_bnum block)
{
bd->dev = dev;
ffc10a84: 93 79 00 1c stw r27,28(r25)
bd->block = block;
ffc10a88: 93 59 00 20 stw r26,32(r25)
bd->avl.left = NULL;
bd->avl.right = NULL;
bd->waiters = 0;
ffc10a8c: 90 19 00 2c stw r0,44(r25)
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
ffc10a90: 41 9e 02 6c beq- cr7,ffc10cfc <rtems_bdbuf_get_buffer_from_lru_list+0x44c>
while (p != NULL)
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
ffc10a94: 80 09 00 18 lwz r0,24(r9)
return 0;
}
while (p != NULL)
{
*buf_prev++ = p;
ffc10a98: 39 4b 00 04 addi r10,r11,4
ffc10a9c: 91 2b 00 00 stw r9,0(r11)
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
ffc10aa0: 7f 9e 00 40 cmplw cr7,r30,r0
ffc10aa4: 81 09 00 1c lwz r8,28(r9)
ffc10aa8: 41 9d 00 14 bgt- cr7,ffc10abc <rtems_bdbuf_get_buffer_from_lru_list+0x20c><== NEVER TAKEN
ffc10aac: 7f 9e 00 00 cmpw cr7,r30,r0
ffc10ab0: 40 9e 00 28 bne- cr7,ffc10ad8 <rtems_bdbuf_get_buffer_from_lru_list+0x228><== NEVER TAKEN
ffc10ab4: 7f 1b 40 40 cmplw cr6,r27,r8
ffc10ab8: 40 99 00 20 ble- cr6,ffc10ad8 <rtems_bdbuf_get_buffer_from_lru_list+0x228><== ALWAYS TAKEN
{
p->avl.cache = 1;
q = p->avl.right;
ffc10abc: 80 09 00 0c lwz r0,12(r9)
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
{
p->avl.cache = 1;
ffc10ac0: 98 e9 00 10 stb r7,16(r9)
q = p->avl.right;
if (q == NULL)
ffc10ac4: 2f 80 00 00 cmpwi cr7,r0,0
ffc10ac8: 41 9e 02 10 beq- cr7,ffc10cd8 <rtems_bdbuf_get_buffer_from_lru_list+0x428>
p->avl.cache = -1;
q = p->avl.left;
if (q == NULL)
{
q = node;
p->avl.left = q;
ffc10acc: 7d 4b 53 78 mr r11,r10
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
ffc10ad0: 7c 09 03 78 mr r9,r0
ffc10ad4: 4b ff ff c0 b ffc10a94 <rtems_bdbuf_get_buffer_from_lru_list+0x1e4>
while (p != NULL)
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
ffc10ad8: 41 9e 00 8c beq- cr7,ffc10b64 <rtems_bdbuf_get_buffer_from_lru_list+0x2b4><== ALWAYS TAKEN
}
}
else if ((p->dev != dev) || (p->block != block))
{
p->avl.cache = -1;
q = p->avl.left;
ffc10adc: 80 09 00 08 lwz r0,8(r9)
break;
}
}
else if ((p->dev != dev) || (p->block != block))
{
p->avl.cache = -1;
ffc10ae0: 98 a9 00 10 stb r5,16(r9)
q = p->avl.left;
if (q == NULL)
ffc10ae4: 2f 80 00 00 cmpwi cr7,r0,0
ffc10ae8: 40 9e ff e4 bne+ cr7,ffc10acc <rtems_bdbuf_get_buffer_from_lru_list+0x21c>
{
q = node;
p->avl.left = q;
ffc10aec: 93 29 00 08 stw r25,8(r9)
ffc10af0: 38 00 ff ff li r0,-1
}
p = q;
}
q->avl.left = q->avl.right = NULL;
ffc10af4: 39 40 00 00 li r10,0
ffc10af8: 2f 80 ff ff cmpwi cr7,r0,-1
ffc10afc: 91 59 00 0c stw r10,12(r25)
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = 1;
ffc10b00: 38 a0 00 01 li r5,1
}
p = q;
}
q->avl.left = q->avl.right = NULL;
ffc10b04: 91 59 00 08 stw r10,8(r25)
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
p = p2;
}
p->avl.bal = 0;
ffc10b08: 38 e0 00 00 li r7,0
p = q;
}
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
ffc10b0c: 99 59 00 11 stb r10,17(r25)
modified = true;
buf_prev--;
while (modified)
{
if (p->avl.cache == -1)
ffc10b10: 41 9e 00 ac beq- cr7,ffc10bbc <rtems_bdbuf_get_buffer_from_lru_list+0x30c>
break;
}
}
else
{
switch (p->avl.bal)
ffc10b14: 88 09 00 11 lbz r0,17(r9)
ffc10b18: 7c 00 07 75 extsb. r0,r0
ffc10b1c: 40 82 00 70 bne- ffc10b8c <rtems_bdbuf_get_buffer_from_lru_list+0x2dc>
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = 1;
ffc10b20: 98 a9 00 11 stb r5,17(r9)
ffc10b24: 7d 2a 4b 78 mr r10,r9
ffc10b28: 39 00 00 01 li r8,1
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
ffc10b2c: 7f 86 58 40 cmplw cr7,r6,r11
ffc10b30: 40 9c 00 7c bge- cr7,ffc10bac <rtems_bdbuf_get_buffer_from_lru_list+0x2fc>
{
p = *--buf_prev;
ffc10b34: 81 2b ff fc lwz r9,-4(r11)
if (p->avl.cache == -1)
ffc10b38: 88 09 00 10 lbz r0,16(r9)
ffc10b3c: 7c 00 07 74 extsb r0,r0
ffc10b40: 2f 80 ff ff cmpwi cr7,r0,-1
ffc10b44: 41 9e 00 94 beq- cr7,ffc10bd8 <rtems_bdbuf_get_buffer_from_lru_list+0x328>
{
p->avl.left = q;
}
else
{
p->avl.right = q;
ffc10b48: 91 49 00 0c stw r10,12(r9)
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
modified = true;
buf_prev--;
while (modified)
ffc10b4c: 2f 08 00 00 cmpwi cr6,r8,0
p->avl.right = q;
}
}
else
{
*root = p;
ffc10b50: 39 6b ff fc addi r11,r11,-4
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
modified = true;
buf_prev--;
while (modified)
ffc10b54: 40 9a ff bc bne+ cr6,ffc10b10 <rtems_bdbuf_get_buffer_from_lru_list+0x260>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc10b58: 38 00 00 01 li r0,1
ffc10b5c: 90 19 00 28 stw r0,40(r25)
if (empty_bd != NULL)
{
rtems_bdbuf_setup_empty_buffer (empty_bd, dev, block);
return empty_bd;
ffc10b60: 4b ff fe 9c b ffc109fc <rtems_bdbuf_get_buffer_from_lru_list+0x14c>
while (p != NULL)
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
ffc10b64: 7f 9b 40 00 cmpw cr7,r27,r8
ffc10b68: 40 9e ff 74 bne+ cr7,ffc10adc <rtems_bdbuf_get_buffer_from_lru_list+0x22c><== NEVER TAKEN
ffc10b6c: 80 09 00 20 lwz r0,32(r9)
ffc10b70: 7f 9a 00 40 cmplw cr7,r26,r0
ffc10b74: 41 bd ff 48 bgt- cr7,ffc10abc <rtems_bdbuf_get_buffer_from_lru_list+0x20c>
q = node;
p->avl.right = q = node;
break;
}
}
else if ((p->dev != dev) || (p->block != block))
ffc10b78: 7f 9a 00 00 cmpw cr7,r26,r0
ffc10b7c: 40 9e ff 60 bne+ cr7,ffc10adc <rtems_bdbuf_get_buffer_from_lru_list+0x22c><== ALWAYS TAKEN
bd->avl.left = NULL;
bd->avl.right = NULL;
bd->waiters = 0;
if (rtems_bdbuf_avl_insert (&bdbuf_cache.tree, bd) != 0)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_RECYCLE);
ffc10b80: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc10b84: 60 63 00 1b ori r3,r3,27 <== NOT EXECUTED
ffc10b88: 4b ff 9f 29 bl ffc0aab0 <rtems_fatal_error_occurred> <== NOT EXECUTED
break;
}
}
else
{
switch (p->avl.bal)
ffc10b8c: 2f 80 00 01 cmpwi cr7,r0,1
ffc10b90: 41 9e 00 60 beq- cr7,ffc10bf0 <rtems_bdbuf_get_buffer_from_lru_list+0x340>
ffc10b94: 2f 80 ff ff cmpwi cr7,r0,-1
ffc10b98: 41 9e 00 48 beq- cr7,ffc10be0 <rtems_bdbuf_get_buffer_from_lru_list+0x330><== ALWAYS TAKEN
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
ffc10b9c: 7f 86 58 40 cmplw cr7,r6,r11 <== NOT EXECUTED
break;
}
}
else
{
switch (p->avl.bal)
ffc10ba0: 7d 2a 4b 78 mr r10,r9 <== NOT EXECUTED
ffc10ba4: 39 00 00 01 li r8,1 <== NOT EXECUTED
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
ffc10ba8: 41 9c ff 8c blt+ cr7,ffc10b34 <rtems_bdbuf_get_buffer_from_lru_list+0x284><== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc10bac: 38 00 00 01 li r0,1
p->avl.right = q;
}
}
else
{
*root = p;
ffc10bb0: 91 5c 00 40 stw r10,64(r28)
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc10bb4: 90 19 00 28 stw r0,40(r25)
ffc10bb8: 4b ff fe 44 b ffc109fc <rtems_bdbuf_get_buffer_from_lru_list+0x14c>
while (modified)
{
if (p->avl.cache == -1)
{
switch (p->avl.bal)
ffc10bbc: 89 49 00 11 lbz r10,17(r9)
ffc10bc0: 7d 4a 07 75 extsb. r10,r10
ffc10bc4: 40 82 00 90 bne- ffc10c54 <rtems_bdbuf_get_buffer_from_lru_list+0x3a4>
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = -1;
ffc10bc8: 98 09 00 11 stb r0,17(r9)
ffc10bcc: 7d 2a 4b 78 mr r10,r9
ffc10bd0: 39 00 00 01 li r8,1
ffc10bd4: 4b ff ff 58 b ffc10b2c <rtems_bdbuf_get_buffer_from_lru_list+0x27c>
{
p = *--buf_prev;
if (p->avl.cache == -1)
{
p->avl.left = q;
ffc10bd8: 91 49 00 08 stw r10,8(r9)
ffc10bdc: 4b ff ff 70 b ffc10b4c <rtems_bdbuf_get_buffer_from_lru_list+0x29c>
else
{
switch (p->avl.bal)
{
case -1:
p->avl.bal = 0;
ffc10be0: 98 e9 00 11 stb r7,17(r9)
ffc10be4: 7d 2a 4b 78 mr r10,r9
modified = false;
ffc10be8: 39 00 00 00 li r8,0
ffc10bec: 4b ff ff 40 b ffc10b2c <rtems_bdbuf_get_buffer_from_lru_list+0x27c>
case 0:
p->avl.bal = 1;
break;
case 1:
p1 = p->avl.right;
ffc10bf0: 81 09 00 0c lwz r8,12(r9)
if (p1->avl.bal == 1) /* simple RR-turn */
ffc10bf4: 88 08 00 11 lbz r0,17(r8)
ffc10bf8: 2f 80 00 01 cmpwi cr7,r0,1
ffc10bfc: 41 9e 00 bc beq- cr7,ffc10cb8 <rtems_bdbuf_get_buffer_from_lru_list+0x408><== ALWAYS TAKEN
p->avl.bal = 0;
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
ffc10c00: 81 48 00 08 lwz r10,8(r8) <== NOT EXECUTED
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
ffc10c04: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc10c08: 88 6a 00 11 lbz r3,17(r10) <== NOT EXECUTED
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
ffc10c0c: 80 8a 00 0c lwz r4,12(r10) <== NOT EXECUTED
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
ffc10c10: 2f 83 00 01 cmpwi cr7,r3,1 <== NOT EXECUTED
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
ffc10c14: 91 0a 00 0c stw r8,12(r10) <== NOT EXECUTED
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
ffc10c18: 90 88 00 08 stw r4,8(r8) <== NOT EXECUTED
p2->avl.right = p1;
p->avl.right = p2->avl.left;
ffc10c1c: 80 8a 00 08 lwz r4,8(r10) <== NOT EXECUTED
p2->avl.left = p;
ffc10c20: 91 2a 00 08 stw r9,8(r10) <== NOT EXECUTED
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
ffc10c24: 90 89 00 0c stw r4,12(r9) <== NOT EXECUTED
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
ffc10c28: 41 9e 00 a8 beq- cr7,ffc10cd0 <rtems_bdbuf_get_buffer_from_lru_list+0x420><== NOT EXECUTED
ffc10c2c: 98 09 00 11 stb r0,17(r9) <== NOT EXECUTED
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
ffc10c30: 88 0a 00 11 lbz r0,17(r10) <== NOT EXECUTED
ffc10c34: 2f 80 00 ff cmpwi cr7,r0,255 <== NOT EXECUTED
ffc10c38: 41 9e 00 14 beq- cr7,ffc10c4c <rtems_bdbuf_get_buffer_from_lru_list+0x39c><== NOT EXECUTED
ffc10c3c: 98 e8 00 11 stb r7,17(r8)
p = p2;
}
p->avl.bal = 0;
ffc10c40: 98 ea 00 11 stb r7,17(r10)
modified = false;
ffc10c44: 39 00 00 00 li r8,0
ffc10c48: 4b ff fe e4 b ffc10b2c <rtems_bdbuf_get_buffer_from_lru_list+0x27c>
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
ffc10c4c: 98 a8 00 11 stb r5,17(r8) <== NOT EXECUTED
ffc10c50: 4b ff ff f0 b ffc10c40 <rtems_bdbuf_get_buffer_from_lru_list+0x390><== NOT EXECUTED
while (modified)
{
if (p->avl.cache == -1)
{
switch (p->avl.bal)
ffc10c54: 2f 8a 00 01 cmpwi cr7,r10,1
ffc10c58: 41 be ff 88 beq- cr7,ffc10be0 <rtems_bdbuf_get_buffer_from_lru_list+0x330>
ffc10c5c: 2f 8a ff ff cmpwi cr7,r10,-1
ffc10c60: 40 9e ff 3c bne+ cr7,ffc10b9c <rtems_bdbuf_get_buffer_from_lru_list+0x2ec><== NEVER TAKEN
case 0:
p->avl.bal = -1;
break;
case -1:
p1 = p->avl.left;
ffc10c64: 81 09 00 08 lwz r8,8(r9)
if (p1->avl.bal == -1) /* simple LL-turn */
ffc10c68: 89 48 00 11 lbz r10,17(r8)
ffc10c6c: 2f 8a 00 ff cmpwi cr7,r10,255
ffc10c70: 41 9e 00 74 beq- cr7,ffc10ce4 <rtems_bdbuf_get_buffer_from_lru_list+0x434><== NEVER TAKEN
p->avl.bal = 0;
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
ffc10c74: 81 48 00 0c lwz r10,12(r8)
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
ffc10c78: 88 8a 00 11 lbz r4,17(r10)
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
ffc10c7c: 80 6a 00 08 lwz r3,8(r10)
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
ffc10c80: 68 84 00 ff xori r4,r4,255
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
ffc10c84: 91 0a 00 08 stw r8,8(r10)
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
ffc10c88: 7c 84 00 34 cntlzw r4,r4
ffc10c8c: 54 84 d9 7e rlwinm r4,r4,27,5,31
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
ffc10c90: 90 68 00 0c stw r3,12(r8)
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
ffc10c94: 98 89 00 11 stb r4,17(r9)
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
ffc10c98: 88 8a 00 11 lbz r4,17(r10)
ffc10c9c: 2f 84 00 01 cmpwi cr7,r4,1
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
ffc10ca0: 80 8a 00 0c lwz r4,12(r10)
p2->avl.right = p;
ffc10ca4: 91 2a 00 0c stw r9,12(r10)
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
ffc10ca8: 90 89 00 08 stw r4,8(r9)
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
ffc10cac: 40 9e ff 90 bne+ cr7,ffc10c3c <rtems_bdbuf_get_buffer_from_lru_list+0x38c><== ALWAYS TAKEN
ffc10cb0: 98 08 00 11 stb r0,17(r8) <== NOT EXECUTED
ffc10cb4: 4b ff ff 8c b ffc10c40 <rtems_bdbuf_get_buffer_from_lru_list+0x390><== NOT EXECUTED
case 1:
p1 = p->avl.right;
if (p1->avl.bal == 1) /* simple RR-turn */
{
p->avl.right = p1->avl.left;
ffc10cb8: 80 08 00 08 lwz r0,8(r8)
p1->avl.left = p;
p->avl.bal = 0;
ffc10cbc: 7d 0a 43 78 mr r10,r8
ffc10cc0: 98 e9 00 11 stb r7,17(r9)
case 1:
p1 = p->avl.right;
if (p1->avl.bal == 1) /* simple RR-turn */
{
p->avl.right = p1->avl.left;
ffc10cc4: 90 09 00 0c stw r0,12(r9)
p1->avl.left = p;
ffc10cc8: 91 28 00 08 stw r9,8(r8)
ffc10ccc: 4b ff ff 74 b ffc10c40 <rtems_bdbuf_get_buffer_from_lru_list+0x390>
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
ffc10cd0: 38 00 ff ff li r0,-1 <== NOT EXECUTED
ffc10cd4: 4b ff ff 58 b ffc10c2c <rtems_bdbuf_get_buffer_from_lru_list+0x37c><== NOT EXECUTED
p->avl.cache = 1;
q = p->avl.right;
if (q == NULL)
{
q = node;
p->avl.right = q = node;
ffc10cd8: 93 29 00 0c stw r25,12(r9)
ffc10cdc: 38 00 00 01 li r0,1
ffc10ce0: 4b ff fe 14 b ffc10af4 <rtems_bdbuf_get_buffer_from_lru_list+0x244>
case -1:
p1 = p->avl.left;
if (p1->avl.bal == -1) /* simple LL-turn */
{
p->avl.left = p1->avl.right;
ffc10ce4: 80 08 00 0c lwz r0,12(r8) <== NOT EXECUTED
p1->avl.right = p;
p->avl.bal = 0;
ffc10ce8: 7d 0a 43 78 mr r10,r8 <== NOT EXECUTED
ffc10cec: 98 e9 00 11 stb r7,17(r9) <== NOT EXECUTED
case -1:
p1 = p->avl.left;
if (p1->avl.bal == -1) /* simple LL-turn */
{
p->avl.left = p1->avl.right;
ffc10cf0: 90 09 00 08 stw r0,8(r9) <== NOT EXECUTED
p1->avl.right = p;
ffc10cf4: 91 28 00 0c stw r9,12(r8) <== NOT EXECUTED
ffc10cf8: 4b ff ff 48 b ffc10c40 <rtems_bdbuf_get_buffer_from_lru_list+0x390><== NOT EXECUTED
bool modified = false;
if (p == NULL)
{
*root = node;
ffc10cfc: 93 3c 00 40 stw r25,64(r28)
node->avl.left = NULL;
ffc10d00: 91 39 00 08 stw r9,8(r25)
node->avl.right = NULL;
ffc10d04: 91 39 00 0c stw r9,12(r25)
node->avl.bal = 0;
ffc10d08: 99 39 00 11 stb r9,17(r25)
ffc10d0c: 4b ff fe 4c b ffc10b58 <rtems_bdbuf_get_buffer_from_lru_list+0x2a8>
ffc10fc0 <rtems_bdbuf_init>:
*
* @return rtems_status_code The initialisation status.
*/
rtems_status_code
rtems_bdbuf_init (void)
{
ffc10fc0: 94 21 ff c8 stwu r1,-56(r1)
ffc10fc4: 7c 08 02 a6 mflr r0
rtems_mode prev_mode;
if (rtems_bdbuf_tracer)
printf ("bdbuf:init\n");
if (rtems_interrupt_is_in_progress())
ffc10fc8: 3d 20 00 00 lis r9,0
*
* @return rtems_status_code The initialisation status.
*/
rtems_status_code
rtems_bdbuf_init (void)
{
ffc10fcc: 90 01 00 3c stw r0,60(r1)
if (rtems_bdbuf_tracer)
printf ("bdbuf:init\n");
if (rtems_interrupt_is_in_progress())
return RTEMS_CALLED_FROM_ISR;
ffc10fd0: 38 60 00 12 li r3,18
rtems_mode prev_mode;
if (rtems_bdbuf_tracer)
printf ("bdbuf:init\n");
if (rtems_interrupt_is_in_progress())
ffc10fd4: 80 09 31 ec lwz r0,12780(r9)
*
* @return rtems_status_code The initialisation status.
*/
rtems_status_code
rtems_bdbuf_init (void)
{
ffc10fd8: 92 a1 00 0c stw r21,12(r1)
rtems_mode prev_mode;
if (rtems_bdbuf_tracer)
printf ("bdbuf:init\n");
if (rtems_interrupt_is_in_progress())
ffc10fdc: 2f 80 00 00 cmpwi cr7,r0,0
*
* @return rtems_status_code The initialisation status.
*/
rtems_status_code
rtems_bdbuf_init (void)
{
ffc10fe0: 92 c1 00 10 stw r22,16(r1)
ffc10fe4: 92 e1 00 14 stw r23,20(r1)
ffc10fe8: 93 01 00 18 stw r24,24(r1)
ffc10fec: 93 21 00 1c stw r25,28(r1)
ffc10ff0: 93 41 00 20 stw r26,32(r1)
ffc10ff4: 93 61 00 24 stw r27,36(r1)
ffc10ff8: 93 81 00 28 stw r28,40(r1)
ffc10ffc: 93 a1 00 2c stw r29,44(r1)
ffc11000: 93 c1 00 30 stw r30,48(r1)
ffc11004: 93 e1 00 34 stw r31,52(r1)
rtems_mode prev_mode;
if (rtems_bdbuf_tracer)
printf ("bdbuf:init\n");
if (rtems_interrupt_is_in_progress())
ffc11008: 41 9e 00 40 beq- cr7,ffc11048 <rtems_bdbuf_init+0x88> <== ALWAYS TAKEN
}
bdbuf_cache.initialised = false;
return RTEMS_UNSATISFIED;
}
ffc1100c: 80 01 00 3c lwz r0,60(r1)
ffc11010: 82 a1 00 0c lwz r21,12(r1)
ffc11014: 7c 08 03 a6 mtlr r0
ffc11018: 82 c1 00 10 lwz r22,16(r1)
ffc1101c: 82 e1 00 14 lwz r23,20(r1)
ffc11020: 83 01 00 18 lwz r24,24(r1)
ffc11024: 83 21 00 1c lwz r25,28(r1)
ffc11028: 83 41 00 20 lwz r26,32(r1)
ffc1102c: 83 61 00 24 lwz r27,36(r1)
ffc11030: 83 81 00 28 lwz r28,40(r1)
ffc11034: 83 a1 00 2c lwz r29,44(r1)
ffc11038: 83 c1 00 30 lwz r30,48(r1)
ffc1103c: 83 e1 00 34 lwz r31,52(r1)
ffc11040: 38 21 00 38 addi r1,r1,56
ffc11044: 4e 80 00 20 blr
return RTEMS_CALLED_FROM_ISR;
/*
* Check the configuration table values.
*/
if ((bdbuf_config.buffer_max % bdbuf_config.buffer_min) != 0)
ffc11048: 3f 80 ff c2 lis r28,-62
ffc1104c: 3b 9c e1 74 addi r28,r28,-7820
ffc11050: 80 1c 00 24 lwz r0,36(r28)
return RTEMS_INVALID_NUMBER;
ffc11054: 38 60 00 0a li r3,10
return RTEMS_CALLED_FROM_ISR;
/*
* Check the configuration table values.
*/
if ((bdbuf_config.buffer_max % bdbuf_config.buffer_min) != 0)
ffc11058: 83 bc 00 20 lwz r29,32(r28)
ffc1105c: 7f 60 eb 96 divwu r27,r0,r29
ffc11060: 7d 3b e9 d6 mullw r9,r27,r29
ffc11064: 7f 80 48 00 cmpw cr7,r0,r9
ffc11068: 40 9e ff a4 bne+ cr7,ffc1100c <rtems_bdbuf_init+0x4c> <== NEVER TAKEN
* We use a special variable to manage the initialisation incase we have
* completing threads doing this. You may get errors if the another thread
* makes a call and we have not finished initialisation.
*/
prev_mode = rtems_bdbuf_disable_preemption ();
if (bdbuf_cache.initialised)
ffc1106c: 3f c0 00 00 lis r30,0
/*
* We use a special variable to manage the initialisation incase we have
* completing threads doing this. You may get errors if the another thread
* makes a call and we have not finished initialisation.
*/
prev_mode = rtems_bdbuf_disable_preemption ();
ffc11070: 4b ff e3 2d bl ffc0f39c <rtems_bdbuf_disable_preemption>
if (bdbuf_cache.initialised)
ffc11074: 3b fe 2a 08 addi r31,r30,10760
ffc11078: 8b 5f 00 88 lbz r26,136(r31)
/*
* We use a special variable to manage the initialisation incase we have
* completing threads doing this. You may get errors if the another thread
* makes a call and we have not finished initialisation.
*/
prev_mode = rtems_bdbuf_disable_preemption ();
ffc1107c: 7c 79 1b 78 mr r25,r3
if (bdbuf_cache.initialised)
ffc11080: 2f 9a 00 00 cmpwi cr7,r26,0
ffc11084: 41 9e 00 10 beq- cr7,ffc11094 <rtems_bdbuf_init+0xd4> <== ALWAYS TAKEN
{
rtems_bdbuf_restore_preemption (prev_mode);
ffc11088: 4b ff e3 61 bl ffc0f3e8 <rtems_bdbuf_restore_preemption><== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
ffc1108c: 38 60 00 0c li r3,12 <== NOT EXECUTED
ffc11090: 4b ff ff 7c b ffc1100c <rtems_bdbuf_init+0x4c> <== NOT EXECUTED
}
memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));
ffc11094: 38 80 00 00 li r4,0
ffc11098: 38 a0 00 90 li r5,144
ffc1109c: 7f e3 fb 78 mr r3,r31
ffc110a0: 48 00 81 91 bl ffc19230 <memset>
bdbuf_cache.initialised = true;
ffc110a4: 38 00 00 01 li r0,1
ffc110a8: 98 1f 00 88 stb r0,136(r31)
rtems_bdbuf_restore_preemption (prev_mode);
ffc110ac: 7f 23 cb 78 mr r3,r25
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc110b0: 3a df 00 0c addi r22,r31,12
ffc110b4: 4b ff e3 35 bl ffc0f3e8 <rtems_bdbuf_restore_preemption>
head->previous = NULL;
tail->previous = head;
ffc110b8: 3a ff 00 08 addi r23,r31,8
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc110bc: 39 9f 00 54 addi r12,r31,84
ffc110c0: 92 df 00 08 stw r22,8(r31)
head->previous = NULL;
tail->previous = head;
ffc110c4: 39 1f 00 50 addi r8,r31,80
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc110c8: 39 3f 00 60 addi r9,r31,96
head->previous = NULL;
ffc110cc: 93 5f 00 0c stw r26,12(r31)
tail->previous = head;
ffc110d0: 38 1f 00 5c addi r0,r31,92
*/
cache_aligment = 32; /* FIXME rtems_cache_get_data_line_size() */
if (cache_aligment <= 0)
cache_aligment = CPU_ALIGNMENT;
bdbuf_cache.sync_device = BDBUF_INVALID_DEV;
ffc110d4: 39 40 ff ff li r10,-1
ffc110d8: 92 ff 00 10 stw r23,16(r31)
ffc110dc: 39 60 ff ff li r11,-1
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc110e0: 3b 1f 00 48 addi r24,r31,72
ffc110e4: 91 5f 00 38 stw r10,56(r31)
head->previous = NULL;
tail->previous = head;
ffc110e8: 3b 3f 00 44 addi r25,r31,68
rtems_chain_initialize_empty (&bdbuf_cache.sync);
/*
* Create the locks for the cache.
*/
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'l'),
ffc110ec: 3c 60 42 44 lis r3,16964
*/
cache_aligment = 32; /* FIXME rtems_cache_get_data_line_size() */
if (cache_aligment <= 0)
cache_aligment = CPU_ALIGNMENT;
bdbuf_cache.sync_device = BDBUF_INVALID_DEV;
ffc110f0: 91 7f 00 3c stw r11,60(r31)
rtems_chain_initialize_empty (&bdbuf_cache.sync);
/*
* Create the locks for the cache.
*/
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'l'),
ffc110f4: 60 63 43 6c ori r3,r3,17260
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc110f8: 93 1f 00 44 stw r24,68(r31)
ffc110fc: 38 80 00 01 li r4,1
ffc11100: 38 a0 00 54 li r5,84
head->previous = NULL;
ffc11104: 93 5f 00 48 stw r26,72(r31)
ffc11108: 38 c0 00 00 li r6,0
ffc1110c: 38 ff 00 28 addi r7,r31,40
tail->previous = head;
ffc11110: 93 3f 00 4c stw r25,76(r31)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc11114: 91 9f 00 50 stw r12,80(r31)
head->previous = NULL;
ffc11118: 93 5f 00 54 stw r26,84(r31)
tail->previous = head;
ffc1111c: 91 1f 00 58 stw r8,88(r31)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc11120: 91 3f 00 5c stw r9,92(r31)
head->previous = NULL;
ffc11124: 93 5f 00 60 stw r26,96(r31)
tail->previous = head;
ffc11128: 90 1f 00 64 stw r0,100(r31)
ffc1112c: 4b ff 8d 91 bl ffc09ebc <rtems_semaphore_create>
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.lock);
if (sc != RTEMS_SUCCESSFUL)
ffc11130: 2f 83 00 00 cmpwi cr7,r3,0
ffc11134: 41 9e 00 7c beq- cr7,ffc111b0 <rtems_bdbuf_init+0x1f0> <== ALWAYS TAKEN
return RTEMS_SUCCESSFUL;
error:
if (bdbuf_cache.swapout != 0)
ffc11138: 80 7e 2a 08 lwz r3,10760(r30) <== NOT EXECUTED
ffc1113c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc11140: 40 9e 00 58 bne- cr7,ffc11198 <rtems_bdbuf_init+0x1d8> <== NOT EXECUTED
rtems_task_delete (bdbuf_cache.swapout);
free (bdbuf_cache.buffers);
ffc11144: 80 7f 00 18 lwz r3,24(r31) <== NOT EXECUTED
ffc11148: 4b ff 4b d5 bl ffc05d1c <free> <== NOT EXECUTED
free (bdbuf_cache.groups);
ffc1114c: 80 7f 00 84 lwz r3,132(r31) <== NOT EXECUTED
ffc11150: 4b ff 4b cd bl ffc05d1c <free> <== NOT EXECUTED
free (bdbuf_cache.bds);
ffc11154: 80 7f 00 14 lwz r3,20(r31) <== NOT EXECUTED
ffc11158: 4b ff 4b c5 bl ffc05d1c <free> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.buffer_waiters.sema);
ffc1115c: 80 7f 00 7c lwz r3,124(r31) <== NOT EXECUTED
ffc11160: 4b ff 8f 59 bl ffc0a0b8 <rtems_semaphore_delete> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.access_waiters.sema);
ffc11164: 80 7f 00 6c lwz r3,108(r31) <== NOT EXECUTED
ffc11168: 4b ff 8f 51 bl ffc0a0b8 <rtems_semaphore_delete> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.transfer_waiters.sema);
ffc1116c: 80 7f 00 74 lwz r3,116(r31) <== NOT EXECUTED
ffc11170: 4b ff 8f 49 bl ffc0a0b8 <rtems_semaphore_delete> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.sync_lock);
ffc11174: 80 7f 00 2c lwz r3,44(r31) <== NOT EXECUTED
ffc11178: 4b ff 8f 41 bl ffc0a0b8 <rtems_semaphore_delete> <== NOT EXECUTED
if (bdbuf_cache.lock != 0)
ffc1117c: 80 1f 00 28 lwz r0,40(r31) <== NOT EXECUTED
ffc11180: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc11184: 40 9e 00 1c bne- cr7,ffc111a0 <rtems_bdbuf_init+0x1e0> <== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
rtems_semaphore_delete (bdbuf_cache.lock);
}
bdbuf_cache.initialised = false;
ffc11188: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc1118c: 98 1f 00 88 stb r0,136(r31) <== NOT EXECUTED
return RTEMS_UNSATISFIED;
ffc11190: 38 60 00 0d li r3,13 <== NOT EXECUTED
ffc11194: 4b ff fe 78 b ffc1100c <rtems_bdbuf_init+0x4c> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
error:
if (bdbuf_cache.swapout != 0)
rtems_task_delete (bdbuf_cache.swapout);
ffc11198: 4b ff 93 e1 bl ffc0a578 <rtems_task_delete> <== NOT EXECUTED
ffc1119c: 4b ff ff a8 b ffc11144 <rtems_bdbuf_init+0x184> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.transfer_waiters.sema);
rtems_semaphore_delete (bdbuf_cache.sync_lock);
if (bdbuf_cache.lock != 0)
{
rtems_bdbuf_unlock_cache ();
ffc111a0: 4b ff e0 85 bl ffc0f224 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.lock);
ffc111a4: 80 7f 00 28 lwz r3,40(r31) <== NOT EXECUTED
ffc111a8: 4b ff 8f 11 bl ffc0a0b8 <rtems_semaphore_delete> <== NOT EXECUTED
ffc111ac: 4b ff ff dc b ffc11188 <rtems_bdbuf_init+0x1c8> <== NOT EXECUTED
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.lock);
if (sc != RTEMS_SUCCESSFUL)
goto error;
rtems_bdbuf_lock_cache ();
ffc111b0: 4b ff dd e9 bl ffc0ef98 <rtems_bdbuf_lock_cache>
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 's'),
ffc111b4: 3c 60 42 44 lis r3,16964
ffc111b8: 60 63 43 73 ori r3,r3,17267
ffc111bc: 38 80 00 01 li r4,1
ffc111c0: 38 a0 00 54 li r5,84
ffc111c4: 38 c0 00 00 li r6,0
ffc111c8: 38 ff 00 2c addi r7,r31,44
ffc111cc: 4b ff 8c f1 bl ffc09ebc <rtems_semaphore_create>
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.sync_lock);
if (sc != RTEMS_SUCCESSFUL)
ffc111d0: 2f 83 00 00 cmpwi cr7,r3,0
ffc111d4: 40 9e ff 64 bne+ cr7,ffc11138 <rtems_bdbuf_init+0x178> <== NEVER TAKEN
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'a'),
ffc111d8: 3c 60 42 44 lis r3,16964
ffc111dc: 60 63 43 61 ori r3,r3,17249
ffc111e0: 38 80 00 00 li r4,0
ffc111e4: 38 a0 00 24 li r5,36
ffc111e8: 38 c0 00 00 li r6,0
ffc111ec: 38 ff 00 6c addi r7,r31,108
ffc111f0: 4b ff 8c cd bl ffc09ebc <rtems_semaphore_create>
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.access_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
ffc111f4: 2f 83 00 00 cmpwi cr7,r3,0
ffc111f8: 40 9e ff 40 bne+ cr7,ffc11138 <rtems_bdbuf_init+0x178> <== NEVER TAKEN
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 't'),
ffc111fc: 3c 60 42 44 lis r3,16964
ffc11200: 60 63 43 74 ori r3,r3,17268
ffc11204: 38 80 00 00 li r4,0
ffc11208: 38 a0 00 24 li r5,36
ffc1120c: 38 c0 00 00 li r6,0
ffc11210: 38 ff 00 74 addi r7,r31,116
ffc11214: 4b ff 8c a9 bl ffc09ebc <rtems_semaphore_create>
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.transfer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
ffc11218: 2f 83 00 00 cmpwi cr7,r3,0
ffc1121c: 40 9e ff 1c bne+ cr7,ffc11138 <rtems_bdbuf_init+0x178> <== NEVER TAKEN
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'b'),
ffc11220: 3c 60 42 44 lis r3,16964
ffc11224: 60 63 43 62 ori r3,r3,17250
ffc11228: 38 80 00 00 li r4,0
ffc1122c: 38 a0 00 24 li r5,36
ffc11230: 38 c0 00 00 li r6,0
ffc11234: 38 ff 00 7c addi r7,r31,124
ffc11238: 4b ff 8c 85 bl ffc09ebc <rtems_semaphore_create>
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.buffer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
ffc1123c: 2f 83 00 00 cmpwi cr7,r3,0
ffc11240: 40 9e fe f8 bne+ cr7,ffc11138 <rtems_bdbuf_init+0x178> <== NEVER TAKEN
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
ffc11244: 83 5c 00 1c lwz r26,28(r28)
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
ffc11248: 38 60 00 40 li r3,64
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
bdbuf_cache.max_bds_per_group =
ffc1124c: 93 7f 00 20 stw r27,32(r31)
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
ffc11250: 7f 5a eb 96 divwu r26,r26,r29
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
bdbuf_cache.group_count =
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
ffc11254: 7f 7a db 96 divwu r27,r26,r27
goto error;
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
ffc11258: 93 5f 00 1c stw r26,28(r31)
bdbuf_config.size / bdbuf_config.buffer_min;
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
bdbuf_cache.group_count =
ffc1125c: 93 7f 00 80 stw r27,128(r31)
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
ffc11260: 7f 44 d3 78 mr r4,r26
ffc11264: 4b ff 48 0d bl ffc05a70 <calloc>
bdbuf_cache.buffer_min_count);
if (!bdbuf_cache.bds)
ffc11268: 2f 83 00 00 cmpwi cr7,r3,0
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
ffc1126c: 90 7f 00 14 stw r3,20(r31)
bdbuf_cache.buffer_min_count);
if (!bdbuf_cache.bds)
ffc11270: 41 be fe c8 beq- cr7,ffc11138 <rtems_bdbuf_init+0x178> <== NEVER TAKEN
goto error;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.groups = calloc (sizeof (rtems_bdbuf_group),
ffc11274: 38 60 00 14 li r3,20
ffc11278: 7f 64 db 78 mr r4,r27
ffc1127c: 4b ff 47 f5 bl ffc05a70 <calloc>
bdbuf_cache.group_count);
if (!bdbuf_cache.groups)
ffc11280: 2f 83 00 00 cmpwi cr7,r3,0
goto error;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.groups = calloc (sizeof (rtems_bdbuf_group),
ffc11284: 90 7f 00 84 stw r3,132(r31)
bdbuf_cache.group_count);
if (!bdbuf_cache.groups)
ffc11288: 41 be fe b0 beq- cr7,ffc11138 <rtems_bdbuf_init+0x178> <== NEVER TAKEN
* aligned. It is possible to free the memory allocated by rtems_memalign()
* with free(). Return 0 if allocated.
*
* The memory allocate allows a
*/
if (rtems_memalign ((void **) &bdbuf_cache.buffers,
ffc1128c: 7c ba e9 d6 mullw r5,r26,r29
ffc11290: 38 7f 00 18 addi r3,r31,24
ffc11294: 38 80 00 20 li r4,32
ffc11298: 48 00 2e 91 bl ffc14128 <rtems_memalign>
ffc1129c: 2f 83 00 00 cmpwi cr7,r3,0
ffc112a0: 40 9e fe 98 bne+ cr7,ffc11138 <rtems_bdbuf_init+0x178> <== NEVER TAKEN
/*
* The cache is empty after opening so we need to add all the buffers to it
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
ffc112a4: 82 bf 00 84 lwz r21,132(r31)
ffc112a8: 3a e0 00 00 li r23,0
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
ffc112ac: 83 1f 00 14 lwz r24,20(r31)
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
{
bd->dev = BDBUF_INVALID_DEV;
ffc112b0: 3b 40 ff ff li r26,-1
/*
* The cache is empty after opening so we need to add all the buffers to it
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
ffc112b4: 82 df 00 18 lwz r22,24(r31)
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
{
bd->dev = BDBUF_INVALID_DEV;
ffc112b8: 3b 60 ff ff li r27,-1
/*
* The cache is empty after opening so we need to add all the buffers to it
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
ffc112bc: 80 1f 00 1c lwz r0,28(r31)
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
ffc112c0: 7f 04 c3 78 mr r4,r24
ffc112c4: 7f 23 cb 78 mr r3,r25
ffc112c8: 7f 97 00 40 cmplw cr7,r23,r0
ffc112cc: 40 9c 00 48 bge- cr7,ffc11314 <rtems_bdbuf_init+0x354>
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
{
bd->dev = BDBUF_INVALID_DEV;
bd->group = group;
bd->buffer = buffer;
ffc112d0: 92 d8 00 24 stw r22,36(r24)
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
ffc112d4: 7e d6 ea 14 add r22,r22,r29
{
bd->dev = BDBUF_INVALID_DEV;
bd->group = group;
ffc112d8: 92 b8 00 30 stw r21,48(r24)
for (b = 0, group = bdbuf_cache.groups,
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
{
bd->dev = BDBUF_INVALID_DEV;
ffc112dc: 93 58 00 18 stw r26,24(r24)
ffc112e0: 93 78 00 1c stw r27,28(r24)
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
ffc112e4: 3b 18 00 40 addi r24,r24,64
ffc112e8: 4b ff 9e 91 bl ffc0b178 <_Chain_Append>
bd->group = group;
bd->buffer = buffer;
rtems_chain_append (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
ffc112ec: 81 3f 00 20 lwz r9,32(r31)
ffc112f0: 7c 17 4b 96 divwu r0,r23,r9
ffc112f4: 7c 00 49 d6 mullw r0,r0,r9
(bdbuf_cache.max_bds_per_group - 1))
ffc112f8: 39 29 ff ff addi r9,r9,-1
bd->group = group;
bd->buffer = buffer;
rtems_chain_append (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
ffc112fc: 7c 00 b8 50 subf r0,r0,r23
ffc11300: 7f 80 48 00 cmpw cr7,r0,r9
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
ffc11304: 3a f7 00 01 addi r23,r23,1
bd->group = group;
bd->buffer = buffer;
rtems_chain_append (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
ffc11308: 40 9e ff b4 bne+ cr7,ffc112bc <rtems_bdbuf_init+0x2fc>
(bdbuf_cache.max_bds_per_group - 1))
group++;
ffc1130c: 3a b5 00 14 addi r21,r21,20
ffc11310: 4b ff ff ac b ffc112bc <rtems_bdbuf_init+0x2fc>
}
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
ffc11314: 81 5f 00 80 lwz r10,128(r31)
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
ffc11318: 81 7f 00 20 lwz r11,32(r31)
if ((b % bdbuf_cache.max_bds_per_group) ==
(bdbuf_cache.max_bds_per_group - 1))
group++;
}
for (b = 0,
ffc1131c: 39 4a 00 01 addi r10,r10,1
group = bdbuf_cache.groups,
ffc11320: 81 3f 00 84 lwz r9,132(r31)
if ((b % bdbuf_cache.max_bds_per_group) ==
(bdbuf_cache.max_bds_per_group - 1))
group++;
}
for (b = 0,
ffc11324: 7d 49 03 a6 mtctr r10
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
ffc11328: 80 1f 00 14 lwz r0,20(r31)
b < bdbuf_cache.group_count;
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
ffc1132c: 55 68 30 32 rlwinm r8,r11,6,0,25
if ((b % bdbuf_cache.max_bds_per_group) ==
(bdbuf_cache.max_bds_per_group - 1))
group++;
}
for (b = 0,
ffc11330: 42 40 00 18 bdz- ffc11348 <rtems_bdbuf_init+0x388>
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
group->bdbuf = bd;
ffc11334: 90 09 00 10 stw r0,16(r9)
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
ffc11338: 7c 00 42 14 add r0,r0,r8
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
ffc1133c: 91 69 00 08 stw r11,8(r9)
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
b++,
group++,
ffc11340: 39 29 00 14 addi r9,r9,20
ffc11344: 4b ff ff ec b ffc11330 <rtems_bdbuf_init+0x370>
* threads.
*/
bdbuf_cache.swapout_enabled = true;
sc = rtems_task_create (rtems_build_name('B', 'S', 'W', 'P'),
bdbuf_config.swapout_priority ?
ffc11348: 80 9c 00 08 lwz r4,8(r28)
/*
* Create and start swapout task. This task will create and manage the worker
* threads.
*/
bdbuf_cache.swapout_enabled = true;
ffc1134c: 38 00 00 01 li r0,1
ffc11350: 98 1f 00 04 stb r0,4(r31)
sc = rtems_task_create (rtems_build_name('B', 'S', 'W', 'P'),
ffc11354: 2f 84 00 00 cmpwi cr7,r4,0
ffc11358: 40 9e 00 08 bne- cr7,ffc11360 <rtems_bdbuf_init+0x3a0> <== ALWAYS TAKEN
ffc1135c: 38 80 00 0f li r4,15 <== NOT EXECUTED
ffc11360: 3c 60 42 53 lis r3,16979
ffc11364: 60 63 57 50 ori r3,r3,22352
ffc11368: 38 a0 20 00 li r5,8192
ffc1136c: 38 c0 04 00 li r6,1024
ffc11370: 38 e0 00 00 li r7,0
ffc11374: 7f e8 fb 78 mr r8,r31
ffc11378: 4b ff 90 89 bl ffc0a400 <rtems_task_create>
RTEMS_BDBUF_SWAPOUT_TASK_PRIORITY_DEFAULT,
SWAPOUT_TASK_STACK_SIZE,
RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,
&bdbuf_cache.swapout);
if (sc != RTEMS_SUCCESSFUL)
ffc1137c: 2f 83 00 00 cmpwi cr7,r3,0
ffc11380: 40 9e fd b8 bne+ cr7,ffc11138 <rtems_bdbuf_init+0x178> <== NEVER TAKEN
goto error;
sc = rtems_task_start (bdbuf_cache.swapout,
ffc11384: 3d 20 00 00 lis r9,0
ffc11388: 80 69 2a 08 lwz r3,10760(r9)
ffc1138c: 3c 80 ff c1 lis r4,-63
ffc11390: 38 84 03 d8 addi r4,r4,984
ffc11394: 7f e5 fb 78 mr r5,r31
ffc11398: 4b ff 93 b9 bl ffc0a750 <rtems_task_start>
rtems_bdbuf_swapout_task,
(rtems_task_argument) &bdbuf_cache);
if (sc != RTEMS_SUCCESSFUL)
ffc1139c: 2f 83 00 00 cmpwi cr7,r3,0
ffc113a0: 40 9e fd 98 bne+ cr7,ffc11138 <rtems_bdbuf_init+0x178> <== NEVER TAKEN
goto error;
rtems_bdbuf_unlock_cache ();
ffc113a4: 4b ff de 81 bl ffc0f224 <rtems_bdbuf_unlock_cache>
return RTEMS_SUCCESSFUL;
ffc113a8: 38 60 00 00 li r3,0
ffc113ac: 4b ff fc 60 b ffc1100c <rtems_bdbuf_init+0x4c>
ffc0ef98 <rtems_bdbuf_lock_cache>:
* Lock the cache. A single task can nest calls.
*/
static void
rtems_bdbuf_lock_cache (void)
{
rtems_bdbuf_lock (bdbuf_cache.lock, RTEMS_BLKDEV_FATAL_BDBUF_CACHE_LOCK);
ffc0ef98: 3d 20 00 00 lis r9,0
/**
* Lock the cache. A single task can nest calls.
*/
static void
rtems_bdbuf_lock_cache (void)
{
ffc0ef9c: 94 21 ff f8 stwu r1,-8(r1)
ffc0efa0: 7c 08 02 a6 mflr r0
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_lock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_obtain (lock,
ffc0efa4: 38 80 00 00 li r4,0
ffc0efa8: 80 69 2a 30 lwz r3,10800(r9)
ffc0efac: 38 a0 00 00 li r5,0
/**
* Lock the cache. A single task can nest calls.
*/
static void
rtems_bdbuf_lock_cache (void)
{
ffc0efb0: 90 01 00 0c stw r0,12(r1)
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_lock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_obtain (lock,
ffc0efb4: 4b ff b1 e1 bl ffc0a194 <rtems_semaphore_obtain>
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc0efb8: 2f 83 00 00 cmpwi cr7,r3,0
ffc0efbc: 40 9e 00 14 bne- cr7,ffc0efd0 <rtems_bdbuf_lock_cache+0x38><== NEVER TAKEN
*/
static void
rtems_bdbuf_lock_cache (void)
{
rtems_bdbuf_lock (bdbuf_cache.lock, RTEMS_BLKDEV_FATAL_BDBUF_CACHE_LOCK);
}
ffc0efc0: 80 01 00 0c lwz r0,12(r1)
ffc0efc4: 38 21 00 08 addi r1,r1,8
ffc0efc8: 7c 08 03 a6 mtlr r0
ffc0efcc: 4e 80 00 20 blr
{
rtems_status_code sc = rtems_semaphore_obtain (lock,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (fatal_error_code);
ffc0efd0: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0efd4: 60 63 00 0d ori r3,r3,13 <== NOT EXECUTED
ffc0efd8: 4b ff ba d9 bl ffc0aab0 <rtems_fatal_error_occurred> <== NOT EXECUTED
ffc0efdc <rtems_bdbuf_lock_sync>:
* Lock the cache's sync. A single task can nest calls.
*/
static void
rtems_bdbuf_lock_sync (void)
{
rtems_bdbuf_lock (bdbuf_cache.sync_lock, RTEMS_BLKDEV_FATAL_BDBUF_SYNC_LOCK);
ffc0efdc: 3d 20 00 00 lis r9,0
/**
* Lock the cache's sync. A single task can nest calls.
*/
static void
rtems_bdbuf_lock_sync (void)
{
ffc0efe0: 94 21 ff f8 stwu r1,-8(r1)
ffc0efe4: 7c 08 02 a6 mflr r0
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_lock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_obtain (lock,
ffc0efe8: 38 80 00 00 li r4,0
ffc0efec: 80 69 2a 34 lwz r3,10804(r9)
ffc0eff0: 38 a0 00 00 li r5,0
/**
* Lock the cache's sync. A single task can nest calls.
*/
static void
rtems_bdbuf_lock_sync (void)
{
ffc0eff4: 90 01 00 0c stw r0,12(r1)
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_lock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_obtain (lock,
ffc0eff8: 4b ff b1 9d bl ffc0a194 <rtems_semaphore_obtain>
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc0effc: 2f 83 00 00 cmpwi cr7,r3,0
ffc0f000: 40 9e 00 14 bne- cr7,ffc0f014 <rtems_bdbuf_lock_sync+0x38><== NEVER TAKEN
*/
static void
rtems_bdbuf_lock_sync (void)
{
rtems_bdbuf_lock (bdbuf_cache.sync_lock, RTEMS_BLKDEV_FATAL_BDBUF_SYNC_LOCK);
}
ffc0f004: 80 01 00 0c lwz r0,12(r1)
ffc0f008: 38 21 00 08 addi r1,r1,8
ffc0f00c: 7c 08 03 a6 mtlr r0
ffc0f010: 4e 80 00 20 blr
{
rtems_status_code sc = rtems_semaphore_obtain (lock,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (fatal_error_code);
ffc0f014: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0f018: 60 63 00 0b ori r3,r3,11 <== NOT EXECUTED
ffc0f01c: 4b ff ba 95 bl ffc0aab0 <rtems_fatal_error_occurred> <== NOT EXECUTED
ffc0f6fc <rtems_bdbuf_obtain_disk.part.8>:
return bd;
}
static rtems_status_code
rtems_bdbuf_obtain_disk (dev_t dev,
ffc0f6fc: 94 21 ff e0 stwu r1,-32(r1)
ffc0f700: 7c 08 02 a6 mflr r0
ffc0f704: 93 61 00 0c stw r27,12(r1)
ffc0f708: 7d 1b 43 78 mr r27,r8
ffc0f70c: 93 81 00 10 stw r28,16(r1)
ffc0f710: 7c dc 33 78 mr r28,r6
ffc0f714: 93 a1 00 14 stw r29,20(r1)
ffc0f718: 93 c1 00 18 stw r30,24(r1)
ffc0f71c: 7c be 2b 78 mr r30,r5
ffc0f720: 93 e1 00 1c stw r31,28(r1)
ffc0f724: 7c ff 3b 78 mr r31,r7
ffc0f728: 90 01 00 24 stw r0,36(r1)
return RTEMS_NOT_CONFIGURED;
/*
* Do not hold the cache lock when obtaining the disk table.
*/
dd = rtems_disk_obtain (dev);
ffc0f72c: 4b ff 55 25 bl ffc04c50 <rtems_disk_obtain>
if (dd == NULL)
ffc0f730: 7c 7d 1b 79 mr. r29,r3
return RTEMS_INVALID_ID;
ffc0f734: 38 60 00 04 li r3,4
/*
* Do not hold the cache lock when obtaining the disk table.
*/
dd = rtems_disk_obtain (dev);
if (dd == NULL)
ffc0f738: 41 82 00 b0 beq- ffc0f7e8 <rtems_bdbuf_obtain_disk.part.8+0xec><== NEVER TAKEN
return RTEMS_INVALID_ID;
*dd_ptr = dd;
if (media_block_ptr != NULL)
ffc0f73c: 2f 9f 00 00 cmpwi cr7,r31,0
*/
dd = rtems_disk_obtain (dev);
if (dd == NULL)
return RTEMS_INVALID_ID;
*dd_ptr = dd;
ffc0f740: 93 bc 00 00 stw r29,0(r28)
if (media_block_ptr != NULL)
ffc0f744: 41 9e 00 3c beq- cr7,ffc0f780 <rtems_bdbuf_obtain_disk.part.8+0x84>
* Compute the media block number. Drivers work with media block number not
* the block number a BD may have as this depends on the block size set by
* the user.
*/
rtems_blkdev_bnum mb = rtems_bdbuf_media_block (block,
dd->block_size,
ffc0f748: 80 7d 00 20 lwz r3,32(r29)
rtems_bdbuf_media_block (rtems_blkdev_bnum block,
size_t block_size,
size_t media_block_size)
{
return (rtems_blkdev_bnum)
((((uint64_t) block) * block_size) / media_block_size);
ffc0f74c: 38 a0 00 00 li r5,0
ffc0f750: 80 dd 00 24 lwz r6,36(r29)
ffc0f754: 7d 5e 19 d6 mullw r10,r30,r3
ffc0f758: 7d 3e 18 16 mulhwu r9,r30,r3
ffc0f75c: 7d 44 53 78 mr r4,r10
ffc0f760: 7d 23 4b 78 mr r3,r9
ffc0f764: 48 00 d4 51 bl ffc1cbb4 <__udivdi3>
* the user.
*/
rtems_blkdev_bnum mb = rtems_bdbuf_media_block (block,
dd->block_size,
dd->media_block_size);
if (mb >= dd->size)
ffc0f768: 80 1d 00 1c lwz r0,28(r29)
ffc0f76c: 7f 84 00 40 cmplw cr7,r4,r0
ffc0f770: 40 9c 00 9c bge- cr7,ffc0f80c <rtems_bdbuf_obtain_disk.part.8+0x110><== NEVER TAKEN
{
rtems_disk_release(dd);
return RTEMS_INVALID_NUMBER;
}
*media_block_ptr = mb + dd->start;
ffc0f774: 80 1d 00 18 lwz r0,24(r29)
ffc0f778: 7c 84 02 14 add r4,r4,r0
ffc0f77c: 90 9f 00 00 stw r4,0(r31)
}
if (bds_per_group_ptr != NULL)
ffc0f780: 2f 9b 00 00 cmpwi cr7,r27,0
}
*bds_per_group_ptr = bds_per_group;
}
return RTEMS_SUCCESSFUL;
ffc0f784: 38 60 00 00 li r3,0
}
*media_block_ptr = mb + dd->start;
}
if (bds_per_group_ptr != NULL)
ffc0f788: 41 9e 00 60 beq- cr7,ffc0f7e8 <rtems_bdbuf_obtain_disk.part.8+0xec>
rtems_bdbuf_bds_per_group (size_t size)
{
size_t bufs_per_size;
size_t bds_per_size;
if (size > bdbuf_config.buffer_max)
ffc0f78c: 3d 20 ff c2 lis r9,-62
*media_block_ptr = mb + dd->start;
}
if (bds_per_group_ptr != NULL)
{
size_t bds_per_group = rtems_bdbuf_bds_per_group (dd->block_size);
ffc0f790: 81 7d 00 20 lwz r11,32(r29)
rtems_bdbuf_bds_per_group (size_t size)
{
size_t bufs_per_size;
size_t bds_per_size;
if (size > bdbuf_config.buffer_max)
ffc0f794: 39 29 e1 74 addi r9,r9,-7820
ffc0f798: 80 09 00 24 lwz r0,36(r9)
ffc0f79c: 7f 8b 00 40 cmplw cr7,r11,r0
ffc0f7a0: 41 9d 00 6c bgt- cr7,ffc0f80c <rtems_bdbuf_obtain_disk.part.8+0x110><== NEVER TAKEN
return 0;
bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;
ffc0f7a4: 80 09 00 20 lwz r0,32(r9)
ffc0f7a8: 39 2b ff ff addi r9,r11,-1
ffc0f7ac: 7d 29 03 96 divwu r9,r9,r0
ffc0f7b0: 39 29 00 01 addi r9,r9,1
for (bds_per_size = 1;
ffc0f7b4: 2b 89 00 01 cmplwi cr7,r9,1
ffc0f7b8: 38 00 00 01 li r0,1
ffc0f7bc: 40 9d 00 10 ble- cr7,ffc0f7cc <rtems_bdbuf_obtain_disk.part.8+0xd0>
bds_per_size < bufs_per_size;
bds_per_size <<= 1)
ffc0f7c0: 54 00 08 3c rlwinm r0,r0,1,0,30
if (size > bdbuf_config.buffer_max)
return 0;
bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;
for (bds_per_size = 1;
ffc0f7c4: 7f 89 00 40 cmplw cr7,r9,r0
ffc0f7c8: 41 9d ff f8 bgt+ cr7,ffc0f7c0 <rtems_bdbuf_obtain_disk.part.8+0xc4><== NEVER TAKEN
bds_per_size < bufs_per_size;
bds_per_size <<= 1)
;
return bdbuf_cache.max_bds_per_group / bds_per_size;
ffc0f7cc: 3d 20 00 00 lis r9,0
ffc0f7d0: 81 29 2a 28 lwz r9,10792(r9)
ffc0f7d4: 7c 09 03 96 divwu r0,r9,r0
if (bds_per_group_ptr != NULL)
{
size_t bds_per_group = rtems_bdbuf_bds_per_group (dd->block_size);
if (bds_per_group == 0)
ffc0f7d8: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f7dc: 41 9e 00 30 beq- cr7,ffc0f80c <rtems_bdbuf_obtain_disk.part.8+0x110><== NEVER TAKEN
{
rtems_disk_release (dd);
return RTEMS_INVALID_NUMBER;
}
*bds_per_group_ptr = bds_per_group;
ffc0f7e0: 90 1b 00 00 stw r0,0(r27)
}
return RTEMS_SUCCESSFUL;
ffc0f7e4: 38 60 00 00 li r3,0
}
ffc0f7e8: 80 01 00 24 lwz r0,36(r1)
ffc0f7ec: 83 61 00 0c lwz r27,12(r1)
ffc0f7f0: 7c 08 03 a6 mtlr r0
ffc0f7f4: 83 81 00 10 lwz r28,16(r1)
ffc0f7f8: 83 a1 00 14 lwz r29,20(r1)
ffc0f7fc: 83 c1 00 18 lwz r30,24(r1)
ffc0f800: 83 e1 00 1c lwz r31,28(r1)
ffc0f804: 38 21 00 20 addi r1,r1,32
ffc0f808: 4e 80 00 20 blr
{
size_t bds_per_group = rtems_bdbuf_bds_per_group (dd->block_size);
if (bds_per_group == 0)
{
rtems_disk_release (dd);
ffc0f80c: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc0f810: 4b ff 54 f5 bl ffc04d04 <rtems_disk_release> <== NOT EXECUTED
*bds_per_group_ptr = bds_per_group;
}
return RTEMS_SUCCESSFUL;
}
ffc0f814: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
size_t bds_per_group = rtems_bdbuf_bds_per_group (dd->block_size);
if (bds_per_group == 0)
{
rtems_disk_release (dd);
return RTEMS_INVALID_NUMBER;
ffc0f818: 38 60 00 0a li r3,10 <== NOT EXECUTED
*bds_per_group_ptr = bds_per_group;
}
return RTEMS_SUCCESSFUL;
}
ffc0f81c: 83 61 00 0c lwz r27,12(r1) <== NOT EXECUTED
ffc0f820: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc0f824: 83 81 00 10 lwz r28,16(r1) <== NOT EXECUTED
ffc0f828: 83 a1 00 14 lwz r29,20(r1) <== NOT EXECUTED
ffc0f82c: 83 c1 00 18 lwz r30,24(r1) <== NOT EXECUTED
ffc0f830: 83 e1 00 1c lwz r31,28(r1) <== NOT EXECUTED
ffc0f834: 38 21 00 20 addi r1,r1,32 <== NOT EXECUTED
ffc0f838: 4e 80 00 20 blr <== NOT EXECUTED
ffc0fd68 <rtems_bdbuf_purge>:
}
}
static void
rtems_bdbuf_purge (rtems_bdbuf_purge_compare compare, dev_t dev)
{
ffc0fd68: 94 21 ff 38 stwu r1,-200(r1)
ffc0fd6c: 7c 08 02 a6 mflr r0
ffc0fd70: 93 21 00 ac stw r25,172(r1)
rtems_bdbuf_purge_compare compare,
dev_t dev)
{
rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
ffc0fd74: 3f 20 00 00 lis r25,0
ffc0fd78: 3b 39 2a 08 addi r25,r25,10760
}
}
static void
rtems_bdbuf_purge (rtems_bdbuf_purge_compare compare, dev_t dev)
{
ffc0fd7c: 90 01 00 cc stw r0,204(r1)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc0fd80: 38 01 00 0c addi r0,r1,12
ffc0fd84: 93 41 00 b0 stw r26,176(r1)
head->previous = NULL;
ffc0fd88: 3b 40 00 00 li r26,0
ffc0fd8c: 93 61 00 b4 stw r27,180(r1)
tail->previous = head;
ffc0fd90: 3b 61 00 08 addi r27,r1,8
ffc0fd94: 93 81 00 b8 stw r28,184(r1)
{
rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
*prev = NULL;
ffc0fd98: 7c 3c 0b 78 mr r28,r1
}
}
static void
rtems_bdbuf_purge (rtems_bdbuf_purge_compare compare, dev_t dev)
{
ffc0fd9c: 93 a1 00 bc stw r29,188(r1)
ffc0fda0: 93 c1 00 c0 stw r30,192(r1)
ffc0fda4: 7c be 2b 78 mr r30,r5
ffc0fda8: 93 e1 00 c4 stw r31,196(r1)
ffc0fdac: 7c df 33 78 mr r31,r6
ffc0fdb0: 92 c1 00 a0 stw r22,160(r1)
ffc0fdb4: 92 e1 00 a4 stw r23,164(r1)
ffc0fdb8: 93 01 00 a8 stw r24,168(r1)
ffc0fdbc: 90 61 00 98 stw r3,152(r1)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc0fdc0: 90 01 00 08 stw r0,8(r1)
head->previous = NULL;
ffc0fdc4: 93 41 00 0c stw r26,12(r1)
tail->previous = head;
ffc0fdc8: 93 61 00 10 stw r27,16(r1)
rtems_chain_control purge_list;
rtems_chain_initialize_empty (&purge_list);
rtems_bdbuf_lock_cache ();
ffc0fdcc: 4b ff f1 cd bl ffc0ef98 <rtems_bdbuf_lock_cache>
rtems_bdbuf_purge_compare compare,
dev_t dev)
{
rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
ffc0fdd0: 83 b9 00 40 lwz r29,64(r25)
*prev = NULL;
ffc0fdd4: 97 5c 00 14 stwu r26,20(r28)
while (cur != NULL)
ffc0fdd8: 2f 9d 00 00 cmpwi cr7,r29,0
ffc0fddc: 41 9e 01 08 beq- cr7,ffc0fee4 <rtems_bdbuf_purge+0x17c> <== NEVER TAKEN
{
if ((*compare) (cur->dev, dev))
{
switch (cur->state)
ffc0fde0: 3f 40 ff c2 lis r26,-62
ffc0fde4: 3b 5a ef 80 addi r26,r26,-4224
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc0fde8: 3a c0 00 06 li r22,6
ffc0fdec: 3a e0 00 0a li r23,10
case RTEMS_BDBUF_STATE_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
break;
case RTEMS_BDBUF_STATE_SYNC:
rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters);
ffc0fdf0: 3b 19 00 70 addi r24,r25,112
*prev = NULL;
while (cur != NULL)
{
if ((*compare) (cur->dev, dev))
ffc0fdf4: 80 01 00 98 lwz r0,152(r1)
ffc0fdf8: 7f c5 f3 78 mr r5,r30
ffc0fdfc: 80 7d 00 18 lwz r3,24(r29)
ffc0fe00: 7f e6 fb 78 mr r6,r31
ffc0fe04: 80 9d 00 1c lwz r4,28(r29)
ffc0fe08: 7c 09 03 a6 mtctr r0
ffc0fe0c: 4e 80 04 21 bctrl
ffc0fe10: 2f 83 00 00 cmpwi cr7,r3,0
ffc0fe14: 41 9e 00 20 beq- cr7,ffc0fe34 <rtems_bdbuf_purge+0xcc> <== NEVER TAKEN
{
switch (cur->state)
ffc0fe18: 80 1d 00 28 lwz r0,40(r29)
ffc0fe1c: 2b 80 00 0a cmplwi cr7,r0,10
ffc0fe20: 40 9d 00 30 ble- cr7,ffc0fe50 <rtems_bdbuf_purge+0xe8> <== ALWAYS TAKEN
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_set_state (cur, RTEMS_BDBUF_STATE_ACCESS_PURGED);
break;
default:
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_STATE_11);
ffc0fe24: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0fe28: 60 63 00 01 ori r3,r3,1 <== NOT EXECUTED
ffc0fe2c: 4b ff ac 85 bl ffc0aab0 <rtems_fatal_error_occurred> <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc0fe30: 92 fd 00 28 stw r23,40(r29)
default:
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_STATE_11);
}
}
if (cur->avl.left != NULL)
ffc0fe34: 80 1d 00 08 lwz r0,8(r29)
ffc0fe38: 2f 80 00 00 cmpwi cr7,r0,0
ffc0fe3c: 41 9e 00 60 beq- cr7,ffc0fe9c <rtems_bdbuf_purge+0x134> <== ALWAYS TAKEN
}
else if (cur->avl.right != NULL)
{
/* Right */
++prev;
*prev = cur;
ffc0fe40: 93 bc 00 04 stw r29,4(r28) <== NOT EXECUTED
ffc0fe44: 7c 1d 03 78 mr r29,r0 <== NOT EXECUTED
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
{
/* Right */
++prev;
ffc0fe48: 3b 9c 00 04 addi r28,r28,4 <== NOT EXECUTED
ffc0fe4c: 4b ff ff a8 b ffc0fdf4 <rtems_bdbuf_purge+0x8c> <== NOT EXECUTED
while (cur != NULL)
{
if ((*compare) (cur->dev, dev))
{
switch (cur->state)
ffc0fe50: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc0fe54: 7c 1a 00 2e lwzx r0,r26,r0
ffc0fe58: 7c 00 d2 14 add r0,r0,r26
ffc0fe5c: 7c 09 03 a6 mtctr r0
ffc0fe60: 4e 80 04 20 bctr
case RTEMS_BDBUF_STATE_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
break;
case RTEMS_BDBUF_STATE_SYNC:
rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters);
ffc0fe64: 7f 03 c3 78 mr r3,r24
ffc0fe68: 4b ff f7 35 bl ffc0f59c <rtems_bdbuf_wake>
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
ffc0fe6c: 81 3d 00 30 lwz r9,48(r29)
ffc0fe70: 81 69 00 0c lwz r11,12(r9)
ffc0fe74: 38 0b ff ff addi r0,r11,-1
ffc0fe78: 90 09 00 0c stw r0,12(r9)
ffc0fe7c: 7f a3 eb 78 mr r3,r29
ffc0fe80: 4b ff b3 29 bl ffc0b1a8 <_Chain_Extract>
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
ffc0fe84: 7f 63 db 78 mr r3,r27
ffc0fe88: 7f a4 eb 78 mr r4,r29
ffc0fe8c: 4b ff b2 ed bl ffc0b178 <_Chain_Append>
default:
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_STATE_11);
}
}
if (cur->avl.left != NULL)
ffc0fe90: 80 1d 00 08 lwz r0,8(r29)
ffc0fe94: 2f 80 00 00 cmpwi cr7,r0,0
ffc0fe98: 40 9e ff a8 bne+ cr7,ffc0fe40 <rtems_bdbuf_purge+0xd8> <== NEVER TAKEN
/* Left */
++prev;
*prev = cur;
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
ffc0fe9c: 80 1d 00 0c lwz r0,12(r29)
ffc0fea0: 2f 80 00 00 cmpwi cr7,r0,0
ffc0fea4: 40 9e ff 9c bne+ cr7,ffc0fe40 <rtems_bdbuf_purge+0xd8> <== NEVER TAKEN
*prev = cur;
cur = cur->avl.right;
}
else
{
while (*prev != NULL && cur == (*prev)->avl.right)
ffc0fea8: 81 7c 00 00 lwz r11,0(r28)
ffc0feac: 2f 8b 00 00 cmpwi cr7,r11,0
ffc0feb0: 41 9e 00 34 beq- cr7,ffc0fee4 <rtems_bdbuf_purge+0x17c> <== ALWAYS TAKEN
ffc0feb4: 80 0b 00 0c lwz r0,12(r11) <== NOT EXECUTED
ffc0feb8: 7f 9d 00 00 cmpw cr7,r29,r0 <== NOT EXECUTED
ffc0febc: 41 be 00 1c beq+ cr7,ffc0fed8 <rtems_bdbuf_purge+0x170> <== NOT EXECUTED
ffc0fec0: 48 00 00 dc b ffc0ff9c <rtems_bdbuf_purge+0x234> <== NOT EXECUTED
ffc0fec4: 80 09 00 0c lwz r0,12(r9) <== NOT EXECUTED
{
/* Up */
cur = *prev;
--prev;
ffc0fec8: 3b 9c ff fc addi r28,r28,-4 <== NOT EXECUTED
*prev = cur;
cur = cur->avl.right;
}
else
{
while (*prev != NULL && cur == (*prev)->avl.right)
ffc0fecc: 7f 80 58 00 cmpw cr7,r0,r11 <== NOT EXECUTED
ffc0fed0: 40 9e 00 cc bne- cr7,ffc0ff9c <rtems_bdbuf_purge+0x234> <== NOT EXECUTED
ffc0fed4: 7d 2b 4b 78 mr r11,r9 <== NOT EXECUTED
ffc0fed8: 81 3c ff fc lwz r9,-4(r28) <== NOT EXECUTED
ffc0fedc: 2f 89 00 00 cmpwi cr7,r9,0 <== NOT EXECUTED
ffc0fee0: 40 9e ff e4 bne+ cr7,ffc0fec4 <rtems_bdbuf_purge+0x15c> <== NOT EXECUTED
while ((node = rtems_chain_get (purge_list)) != NULL)
{
rtems_bdbuf_buffer *bd = (rtems_bdbuf_buffer *) node;
if (bd->waiters == 0)
wake_buffer_waiters = true;
ffc0fee4: 3b a0 00 00 li r29,0
ffc0fee8: 3b c0 00 01 li r30,1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head(
Chain_Control *the_chain
)
{
return &the_chain->Head.Node;
ffc0feec: 3b 99 00 44 addi r28,r25,68
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
ffc0fef0: 7f 63 db 78 mr r3,r27
ffc0fef4: 4b ff b2 dd bl ffc0b1d0 <_Chain_Get>
rtems_bdbuf_purge_list (rtems_chain_control *purge_list)
{
bool wake_buffer_waiters = false;
rtems_chain_node *node = NULL;
while ((node = rtems_chain_get (purge_list)) != NULL)
ffc0fef8: 7c 7a 1b 79 mr. r26,r3
ffc0fefc: 41 82 00 4c beq- ffc0ff48 <rtems_bdbuf_purge+0x1e0>
{
rtems_bdbuf_buffer *bd = (rtems_bdbuf_buffer *) node;
if (bd->waiters == 0)
ffc0ff00: 80 1a 00 2c lwz r0,44(r26)
ffc0ff04: 2f 80 00 00 cmpwi cr7,r0,0
ffc0ff08: 40 9e 00 08 bne- cr7,ffc0ff10 <rtems_bdbuf_purge+0x1a8>
wake_buffer_waiters = true;
ffc0ff0c: 3b a0 00 01 li r29,1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc0ff10: 93 da 00 28 stw r30,40(r26)
static void
rtems_bdbuf_discard_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_make_empty (bd);
if (bd->waiters == 0)
ffc0ff14: 83 1a 00 2c lwz r24,44(r26)
ffc0ff18: 2f 98 00 00 cmpwi cr7,r24,0
ffc0ff1c: 40 9e ff d4 bne+ cr7,ffc0fef0 <rtems_bdbuf_purge+0x188>
{
rtems_bdbuf_remove_from_tree (bd);
ffc0ff20: 7f 43 d3 78 mr r3,r26
ffc0ff24: 4b ff f9 19 bl ffc0f83c <rtems_bdbuf_remove_from_tree>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc0ff28: 93 1a 00 28 stw r24,40(r26)
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
ffc0ff2c: 7f 44 d3 78 mr r4,r26
ffc0ff30: 7f 83 e3 78 mr r3,r28
ffc0ff34: 48 00 56 11 bl ffc15544 <_Chain_Insert>
ffc0ff38: 7f 63 db 78 mr r3,r27
ffc0ff3c: 4b ff b2 95 bl ffc0b1d0 <_Chain_Get>
rtems_bdbuf_purge_list (rtems_chain_control *purge_list)
{
bool wake_buffer_waiters = false;
rtems_chain_node *node = NULL;
while ((node = rtems_chain_get (purge_list)) != NULL)
ffc0ff40: 7c 7a 1b 79 mr. r26,r3
ffc0ff44: 40 82 ff bc bne+ ffc0ff00 <rtems_bdbuf_purge+0x198> <== NEVER TAKEN
wake_buffer_waiters = true;
rtems_bdbuf_discard_buffer (bd);
}
if (wake_buffer_waiters)
ffc0ff48: 2f 9d 00 00 cmpwi cr7,r29,0
ffc0ff4c: 41 be 00 0c beq+ cr7,ffc0ff58 <rtems_bdbuf_purge+0x1f0>
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
ffc0ff50: 38 79 00 78 addi r3,r25,120
ffc0ff54: 4b ff f6 49 bl ffc0f59c <rtems_bdbuf_wake>
rtems_chain_initialize_empty (&purge_list);
rtems_bdbuf_lock_cache ();
rtems_bdbuf_gather_for_purge (&purge_list, compare, dev);
rtems_bdbuf_purge_list (&purge_list);
rtems_bdbuf_unlock_cache ();
ffc0ff58: 4b ff f2 cd bl ffc0f224 <rtems_bdbuf_unlock_cache>
}
ffc0ff5c: 80 01 00 cc lwz r0,204(r1)
ffc0ff60: 82 c1 00 a0 lwz r22,160(r1)
ffc0ff64: 7c 08 03 a6 mtlr r0
ffc0ff68: 82 e1 00 a4 lwz r23,164(r1)
ffc0ff6c: 83 01 00 a8 lwz r24,168(r1)
ffc0ff70: 83 21 00 ac lwz r25,172(r1)
ffc0ff74: 83 41 00 b0 lwz r26,176(r1)
ffc0ff78: 83 61 00 b4 lwz r27,180(r1)
ffc0ff7c: 83 81 00 b8 lwz r28,184(r1)
ffc0ff80: 83 a1 00 bc lwz r29,188(r1)
ffc0ff84: 83 c1 00 c0 lwz r30,192(r1)
ffc0ff88: 83 e1 00 c4 lwz r31,196(r1)
ffc0ff8c: 38 21 00 c8 addi r1,r1,200
ffc0ff90: 4e 80 00 20 blr
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc0ff94: 92 dd 00 28 stw r22,40(r29)
ffc0ff98: 4b ff fe 9c b ffc0fe34 <rtems_bdbuf_purge+0xcc>
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
*prev = NULL;
while (cur != NULL)
ffc0ff9c: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc0ffa0: 41 9e ff 44 beq+ cr7,ffc0fee4 <rtems_bdbuf_purge+0x17c> <== NOT EXECUTED
ffc0ffa4: 7c 1d 03 78 mr r29,r0 <== NOT EXECUTED
ffc0ffa8: 4b ff fe 4c b ffc0fdf4 <rtems_bdbuf_purge+0x8c> <== NOT EXECUTED
ffc0ef88 <rtems_bdbuf_purge_compare_major>:
static bool
rtems_bdbuf_purge_compare_major (dev_t a, dev_t b)
{
return rtems_filesystem_dev_major_t (a) == rtems_filesystem_dev_major_t (b);
}
ffc0ef88: 7c 63 2a 78 xor r3,r3,r5 <== NOT EXECUTED
ffc0ef8c: 7c 63 00 34 cntlzw r3,r3 <== NOT EXECUTED
ffc0ef90: 54 63 d9 7e rlwinm r3,r3,27,5,31 <== NOT EXECUTED
ffc0ef94: 4e 80 00 20 blr <== NOT EXECUTED
ffc11c5c <rtems_bdbuf_purge_major>:
return rtems_filesystem_dev_major_t (a) == rtems_filesystem_dev_major_t (b);
}
void
rtems_bdbuf_purge_major (rtems_device_major_number major)
{
ffc11c5c: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
dev_t dev = rtems_filesystem_make_dev_t (major, 0);
rtems_bdbuf_purge (rtems_bdbuf_purge_compare_major, dev);
ffc11c60: 3c 60 ff c1 lis r3,-63 <== NOT EXECUTED
ffc11c64: 38 63 ef 88 addi r3,r3,-4216 <== NOT EXECUTED
ffc11c68: 38 c0 00 00 li r6,0 <== NOT EXECUTED
ffc11c6c: 4b ff e0 fc b ffc0fd68 <rtems_bdbuf_purge> <== NOT EXECUTED
ffc114d4 <rtems_bdbuf_read>:
rtems_status_code
rtems_bdbuf_read (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
ffc114d4: 94 21 ff a8 stwu r1,-88(r1)
ffc114d8: 7c 08 02 a6 mflr r0
ffc114dc: 93 c1 00 50 stw r30,80(r1)
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
ffc114e0: 3f c0 00 00 lis r30,0
ffc114e4: 3b de 2a 08 addi r30,r30,10760
ffc114e8: 89 3e 00 88 lbz r9,136(r30)
rtems_status_code
rtems_bdbuf_read (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
ffc114ec: 90 01 00 5c stw r0,92(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
ffc114f0: 38 00 00 00 li r0,0
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
ffc114f4: 2f 89 00 00 cmpwi cr7,r9,0
rtems_status_code
rtems_bdbuf_read (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
ffc114f8: 93 e1 00 54 stw r31,84(r1)
ffc114fc: 7c 3f 0b 78 mr r31,r1
ffc11500: 92 e1 00 34 stw r23,52(r1)
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
return RTEMS_NOT_CONFIGURED;
ffc11504: 3a e0 00 16 li r23,22
rtems_status_code
rtems_bdbuf_read (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
ffc11508: 93 a1 00 4c stw r29,76(r1)
ffc1150c: 7c dd 33 78 mr r29,r6
ffc11510: 92 01 00 18 stw r16,24(r1)
ffc11514: 92 21 00 1c stw r17,28(r1)
ffc11518: 92 41 00 20 stw r18,32(r1)
ffc1151c: 92 61 00 24 stw r19,36(r1)
ffc11520: 92 81 00 28 stw r20,40(r1)
ffc11524: 92 a1 00 2c stw r21,44(r1)
ffc11528: 92 c1 00 30 stw r22,48(r1)
ffc1152c: 93 01 00 38 stw r24,56(r1)
ffc11530: 93 21 00 3c stw r25,60(r1)
ffc11534: 93 41 00 40 stw r26,64(r1)
ffc11538: 93 61 00 44 stw r27,68(r1)
ffc1153c: 93 81 00 48 stw r28,72(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
ffc11540: 90 1f 00 10 stw r0,16(r31)
rtems_blkdev_request *req = NULL;
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block = 0;
ffc11544: 90 1f 00 0c stw r0,12(r31)
size_t bds_per_group = 0;
ffc11548: 90 1f 00 08 stw r0,8(r31)
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
ffc1154c: 40 9e 00 5c bne- cr7,ffc115a8 <rtems_bdbuf_read+0xd4> <== ALWAYS TAKEN
rtems_bdbuf_unlock_cache ();
rtems_bdbuf_release_disk (dd);
return sc;
}
ffc11550: 39 7f 00 58 addi r11,r31,88
ffc11554: 80 0b 00 04 lwz r0,4(r11)
ffc11558: 7e e3 bb 78 mr r3,r23
ffc1155c: 82 0b ff c0 lwz r16,-64(r11)
ffc11560: 7c 08 03 a6 mtlr r0
ffc11564: 82 2b ff c4 lwz r17,-60(r11)
ffc11568: 82 4b ff c8 lwz r18,-56(r11)
ffc1156c: 82 6b ff cc lwz r19,-52(r11)
ffc11570: 82 8b ff d0 lwz r20,-48(r11)
ffc11574: 82 ab ff d4 lwz r21,-44(r11)
ffc11578: 82 cb ff d8 lwz r22,-40(r11)
ffc1157c: 82 eb ff dc lwz r23,-36(r11)
ffc11580: 83 0b ff e0 lwz r24,-32(r11)
ffc11584: 83 2b ff e4 lwz r25,-28(r11)
ffc11588: 83 4b ff e8 lwz r26,-24(r11)
ffc1158c: 83 6b ff ec lwz r27,-20(r11)
ffc11590: 83 8b ff f0 lwz r28,-16(r11)
ffc11594: 83 ab ff f4 lwz r29,-12(r11)
ffc11598: 83 cb ff f8 lwz r30,-8(r11)
ffc1159c: 83 eb ff fc lwz r31,-4(r11)
ffc115a0: 7d 61 5b 78 mr r1,r11
ffc115a4: 4e 80 00 20 blr
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
ffc115a8: 38 df 00 10 addi r6,r31,16
ffc115ac: 38 ff 00 0c addi r7,r31,12
ffc115b0: 39 1f 00 08 addi r8,r31,8
ffc115b4: 4b ff e1 49 bl ffc0f6fc <rtems_bdbuf_obtain_disk.part.8>
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block = 0;
size_t bds_per_group = 0;
sc = rtems_bdbuf_obtain_disk (dev, block, &dd, &media_block, &bds_per_group);
if (sc != RTEMS_SUCCESSFUL)
ffc115b8: 7c 77 1b 79 mr. r23,r3
ffc115bc: 40 a2 ff 94 bne- ffc11550 <rtems_bdbuf_read+0x7c> <== NEVER TAKEN
/*
* TODO: This type of request structure is wrong and should be removed.
*/
#define bdbuf_alloc(size) __builtin_alloca (size)
req = bdbuf_alloc (sizeof (rtems_blkdev_request) +
ffc115c0: 3d 60 ff c2 lis r11,-62
ffc115c4: 81 21 00 00 lwz r9,0(r1)
ffc115c8: 83 0b e1 74 lwz r24,-7820(r11)
ffc115cc: 3b 18 00 01 addi r24,r24,1
ffc115d0: 57 00 20 36 rlwinm r0,r24,4,0,27
ffc115d4: 20 00 ff d0 subfic r0,r0,-48
ffc115d8: 7d 21 01 6e stwux r9,r1,r0
if (rtems_bdbuf_tracer)
printf ("bdbuf:read: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block + dd->start, block, (unsigned) dev);
rtems_bdbuf_lock_cache ();
ffc115dc: 4b ff d9 bd bl ffc0ef98 <rtems_bdbuf_lock_cache>
rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
ffc115e0: 81 3f 00 10 lwz r9,16(r31)
/*
* TODO: This type of request structure is wrong and should be removed.
*/
#define bdbuf_alloc(size) __builtin_alloca (size)
req = bdbuf_alloc (sizeof (rtems_blkdev_request) +
ffc115e4: 3b 21 00 17 addi r25,r1,23
if (rtems_bdbuf_tracer)
printf ("bdbuf:read: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block + dd->start, block, (unsigned) dev);
rtems_bdbuf_lock_cache ();
rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
ffc115e8: 83 7f 00 0c lwz r27,12(r31)
rtems_blkdev_request *req,
rtems_bdbuf_buffer **bd_ptr)
{
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block_end = dd->start + dd->size;
rtems_blkdev_bnum media_block_count = dd->block_size / dd->media_block_size;
ffc115ec: 82 69 00 20 lwz r19,32(r9)
/*
* TODO: This type of request structure is wrong and should be removed.
*/
#define bdbuf_alloc(size) __builtin_alloca (size)
req = bdbuf_alloc (sizeof (rtems_blkdev_request) +
ffc115f0: 57 39 00 36 rlwinm r25,r25,0,0,27
rtems_blkdev_request *req,
rtems_bdbuf_buffer **bd_ptr)
{
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block_end = dd->start + dd->size;
rtems_blkdev_bnum media_block_count = dd->block_size / dd->media_block_size;
ffc115f4: 82 89 00 24 lwz r20,36(r9)
dev_t dev = dd->dev;
ffc115f8: 83 89 00 00 lwz r28,0(r9)
ffc115fc: 83 49 00 04 lwz r26,4(r9)
rtems_blkdev_request *req,
rtems_bdbuf_buffer **bd_ptr)
{
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block_end = dd->start + dd->size;
rtems_blkdev_bnum media_block_count = dd->block_size / dd->media_block_size;
ffc11600: 7e 93 a3 96 divwu r20,r19,r20
size_t bds_per_group,
rtems_blkdev_request *req,
rtems_bdbuf_buffer **bd_ptr)
{
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block_end = dd->start + dd->size;
ffc11604: 82 a9 00 18 lwz r21,24(r9)
ffc11608: 82 29 00 1c lwz r17,28(r9)
uint32_t transfer_count = bdbuf_config.max_read_ahead_blocks + 1;
if (media_block_end - media_block < transfer_count)
transfer_count = media_block_end - media_block;
req->req = RTEMS_BLKDEV_REQ_READ;
ffc1160c: 92 f9 00 00 stw r23,0(r25)
req->req_done = rtems_bdbuf_transfer_done;
req->done_arg = req;
ffc11610: 93 39 00 08 stw r25,8(r25)
if (rtems_bdbuf_tracer)
printf ("bdbuf:read: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block + dd->start, block, (unsigned) dev);
rtems_bdbuf_lock_cache ();
rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
ffc11614: 82 5f 00 08 lwz r18,8(r31)
if (media_block_end - media_block < transfer_count)
transfer_count = media_block_end - media_block;
req->req = RTEMS_BLKDEV_REQ_READ;
req->req_done = rtems_bdbuf_transfer_done;
ffc11618: 3d 20 ff c1 lis r9,-63
ffc1161c: 38 09 f3 10 addi r0,r9,-3312
ffc11620: 90 19 00 04 stw r0,4(r25)
req->done_arg = req;
req->io_task = rtems_task_self ();
ffc11624: 48 00 3b 11 bl ffc15134 <rtems_task_self>
req->status = RTEMS_RESOURCE_IN_USE;
ffc11628: 38 00 00 0c li r0,12
transfer_count = media_block_end - media_block;
req->req = RTEMS_BLKDEV_REQ_READ;
req->req_done = rtems_bdbuf_transfer_done;
req->done_arg = req;
req->io_task = rtems_task_self ();
ffc1162c: 90 79 00 14 stw r3,20(r25)
req->status = RTEMS_RESOURCE_IN_USE;
req->bufnum = 0;
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
ffc11630: 7f 44 d3 78 mr r4,r26
ffc11634: 7f 83 e3 78 mr r3,r28
req->req = RTEMS_BLKDEV_REQ_READ;
req->req_done = rtems_bdbuf_transfer_done;
req->done_arg = req;
req->io_task = rtems_task_self ();
req->status = RTEMS_RESOURCE_IN_USE;
ffc11638: 90 19 00 0c stw r0,12(r25)
req->bufnum = 0;
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
ffc1163c: 7f 65 db 78 mr r5,r27
ffc11640: 7e 46 93 78 mr r6,r18
req->req = RTEMS_BLKDEV_REQ_READ;
req->req_done = rtems_bdbuf_transfer_done;
req->done_arg = req;
req->io_task = rtems_task_self ();
req->status = RTEMS_RESOURCE_IN_USE;
req->bufnum = 0;
ffc11644: 92 f9 00 10 stw r23,16(r25)
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
ffc11648: 4b ff f6 c9 bl ffc10d10 <rtems_bdbuf_get_buffer_for_access>
req->bufs [0].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
switch (bd->state)
ffc1164c: 80 03 00 28 lwz r0,40(r3)
req->done_arg = req;
req->io_task = rtems_task_self ();
req->status = RTEMS_RESOURCE_IN_USE;
req->bufnum = 0;
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
ffc11650: 7c 76 1b 78 mr r22,r3
*bd_ptr = bd;
req->bufs [0].user = bd;
ffc11654: 90 79 00 24 stw r3,36(r25)
req->bufs [0].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
switch (bd->state)
ffc11658: 2f 80 00 02 cmpwi cr7,r0,2
*bd_ptr = bd;
req->bufs [0].user = bd;
req->bufs [0].block = media_block;
req->bufs [0].length = block_size;
req->bufs [0].buffer = bd->buffer;
ffc1165c: 81 23 00 24 lwz r9,36(r3)
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
*bd_ptr = bd;
req->bufs [0].user = bd;
req->bufs [0].block = media_block;
ffc11660: 93 79 00 18 stw r27,24(r25)
req->bufs [0].length = block_size;
ffc11664: 92 79 00 1c stw r19,28(r25)
req->bufs [0].buffer = bd->buffer;
ffc11668: 91 39 00 20 stw r9,32(r25)
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
switch (bd->state)
ffc1166c: 41 9e 01 44 beq- cr7,ffc117b0 <rtems_bdbuf_read+0x2dc>
ffc11670: 2f 80 00 07 cmpwi cr7,r0,7
ffc11674: 41 9e 01 3c beq- cr7,ffc117b0 <rtems_bdbuf_read+0x2dc>
ffc11678: 2f 80 00 01 cmpwi cr7,r0,1
ffc1167c: 41 9e 00 14 beq- cr7,ffc11690 <rtems_bdbuf_read+0x1bc> <== ALWAYS TAKEN
return;
case RTEMS_BDBUF_STATE_EMPTY:
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_1);
ffc11680: 3c 80 42 00 lis r4,16896 <== NOT EXECUTED
ffc11684: 80 63 00 28 lwz r3,40(r3) <== NOT EXECUTED
ffc11688: 60 84 00 1d ori r4,r4,29 <== NOT EXECUTED
ffc1168c: 4b ff d9 95 bl ffc0f020 <rtems_bdbuf_fatal> <== NOT EXECUTED
size_t bds_per_group,
rtems_blkdev_request *req,
rtems_bdbuf_buffer **bd_ptr)
{
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block_end = dd->start + dd->size;
ffc11690: 7e 31 aa 14 add r17,r17,r21
dev_t dev = dd->dev;
uint32_t block_size = dd->block_size;
uint32_t transfer_index = 1;
uint32_t transfer_count = bdbuf_config.max_read_ahead_blocks + 1;
if (media_block_end - media_block < transfer_count)
ffc11694: 7e 3b 88 50 subf r17,r27,r17
req->bufs [0].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
switch (bd->state)
ffc11698: 7f 91 c0 40 cmplw cr7,r17,r24
ffc1169c: 40 9d 00 08 ble- cr7,ffc116a4 <rtems_bdbuf_read+0x1d0>
ffc116a0: 7f 11 c3 78 mr r17,r24
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_1);
break;
}
while (transfer_index < transfer_count)
ffc116a4: 2b 91 00 01 cmplwi cr7,r17,1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc116a8: 38 00 00 09 li r0,9
ffc116ac: 90 16 00 28 stw r0,40(r22)
return;
case RTEMS_BDBUF_STATE_EMPTY:
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_1);
ffc116b0: 7f 38 cb 78 mr r24,r25
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block_end = dd->start + dd->size;
rtems_blkdev_bnum media_block_count = dd->block_size / dd->media_block_size;
dev_t dev = dd->dev;
uint32_t block_size = dd->block_size;
uint32_t transfer_index = 1;
ffc116b4: 3a a0 00 01 li r21,1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc116b8: 3a 00 00 09 li r16,9
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_1);
break;
}
while (transfer_index < transfer_count)
ffc116bc: 40 9d 00 8c ble- cr7,ffc11748 <rtems_bdbuf_read+0x274>
rtems_blkdev_bnum block,
size_t bds_per_group)
{
rtems_bdbuf_buffer *bd = NULL;
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dev, block);
ffc116c0: 81 3e 00 40 lwz r9,64(r30)
break;
}
while (transfer_index < transfer_count)
{
media_block += media_block_count;
ffc116c4: 7f 7b a2 14 add r27,r27,r20
dev_t dev,
rtems_blkdev_bnum block)
{
rtems_bdbuf_buffer* p = *root;
while ((p != NULL) && ((p->dev != dev) || (p->block != block)))
ffc116c8: 2f 89 00 00 cmpwi cr7,r9,0
ffc116cc: 41 9e 00 28 beq- cr7,ffc116f4 <rtems_bdbuf_read+0x220> <== NEVER TAKEN
ffc116d0: 80 09 00 18 lwz r0,24(r9)
ffc116d4: 81 69 00 1c lwz r11,28(r9)
ffc116d8: 7f 9c 00 00 cmpw cr7,r28,r0
ffc116dc: 41 9e 00 b0 beq- cr7,ffc1178c <rtems_bdbuf_read+0x2b8> <== ALWAYS TAKEN
{
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
ffc116e0: 7f 1c 00 40 cmplw cr6,r28,r0 <== NOT EXECUTED
ffc116e4: 40 99 00 94 ble- cr6,ffc11778 <rtems_bdbuf_read+0x2a4> <== NOT EXECUTED
{
p = p->avl.right;
ffc116e8: 81 29 00 0c lwz r9,12(r9)
dev_t dev,
rtems_blkdev_bnum block)
{
rtems_bdbuf_buffer* p = *root;
while ((p != NULL) && ((p->dev != dev) || (p->block != block)))
ffc116ec: 2f 89 00 00 cmpwi cr7,r9,0
ffc116f0: 40 9e ff e0 bne+ cr7,ffc116d0 <rtems_bdbuf_read+0x1fc> <== NEVER TAKEN
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dev, block);
if (bd == NULL)
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dev, block, bds_per_group);
ffc116f4: 7f 83 e3 78 mr r3,r28
ffc116f8: 7f 44 d3 78 mr r4,r26
ffc116fc: 7f 65 db 78 mr r5,r27
ffc11700: 7e 46 93 78 mr r6,r18
ffc11704: 4b ff f1 ad bl ffc108b0 <rtems_bdbuf_get_buffer_from_lru_list>
if (bd != NULL)
ffc11708: 2c 03 00 00 cmpwi r3,0
ffc1170c: 41 82 00 3c beq- ffc11748 <rtems_bdbuf_read+0x274> <== ALWAYS TAKEN
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
ffc11710: 81 23 00 30 lwz r9,48(r3) <== NOT EXECUTED
req->bufs [transfer_index].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read-ahead", bd);
++transfer_index;
ffc11714: 3a b5 00 01 addi r21,r21,1 <== NOT EXECUTED
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_1);
break;
}
while (transfer_index < transfer_count)
ffc11718: 7f 95 88 00 cmpw cr7,r21,r17 <== NOT EXECUTED
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
ffc1171c: 81 69 00 0c lwz r11,12(r9) <== NOT EXECUTED
ffc11720: 38 0b 00 01 addi r0,r11,1 <== NOT EXECUTED
ffc11724: 90 09 00 0c stw r0,12(r9) <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc11728: 92 03 00 28 stw r16,40(r3) <== NOT EXECUTED
if (bd == NULL)
break;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
req->bufs [transfer_index].user = bd;
ffc1172c: 90 78 00 34 stw r3,52(r24) <== NOT EXECUTED
req->bufs [transfer_index].block = media_block;
ffc11730: 93 78 00 28 stw r27,40(r24) <== NOT EXECUTED
req->bufs [transfer_index].length = block_size;
ffc11734: 92 78 00 2c stw r19,44(r24) <== NOT EXECUTED
req->bufs [transfer_index].buffer = bd->buffer;
ffc11738: 80 03 00 24 lwz r0,36(r3) <== NOT EXECUTED
ffc1173c: 90 18 00 30 stw r0,48(r24) <== NOT EXECUTED
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read-ahead", bd);
++transfer_index;
ffc11740: 3b 18 00 10 addi r24,r24,16 <== NOT EXECUTED
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_1);
break;
}
while (transfer_index < transfer_count)
ffc11744: 40 9e ff 7c bne+ cr7,ffc116c0 <rtems_bdbuf_read+0x1ec> <== NOT EXECUTED
rtems_bdbuf_show_users ("read-ahead", bd);
++transfer_index;
}
req->bufnum = transfer_index;
ffc11748: 92 b9 00 10 stw r21,16(r25)
media_block + dd->start, block, (unsigned) dev);
rtems_bdbuf_lock_cache ();
rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
if (req->bufnum > 0)
ffc1174c: 2f 95 00 00 cmpwi cr7,r21,0
ffc11750: 40 9e 00 68 bne- cr7,ffc117b8 <rtems_bdbuf_read+0x2e4>
}
}
if (sc == RTEMS_SUCCESSFUL)
{
switch (bd->state)
ffc11754: 80 16 00 28 lwz r0,40(r22)
ffc11758: 2f 80 00 02 cmpwi cr7,r0,2
ffc1175c: 41 9e 00 a8 beq- cr7,ffc11804 <rtems_bdbuf_read+0x330>
ffc11760: 2f 80 00 07 cmpwi cr7,r0,7
ffc11764: 41 9e 00 90 beq- cr7,ffc117f4 <rtems_bdbuf_read+0x320> <== ALWAYS TAKEN
break;
case RTEMS_BDBUF_STATE_MODIFIED:
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_4);
ffc11768: 3c 80 42 00 lis r4,16896 <== NOT EXECUTED
ffc1176c: 80 76 00 28 lwz r3,40(r22) <== NOT EXECUTED
ffc11770: 60 84 00 02 ori r4,r4,2 <== NOT EXECUTED
ffc11774: 4b ff d8 ad bl ffc0f020 <rtems_bdbuf_fatal> <== NOT EXECUTED
{
rtems_bdbuf_buffer* p = *root;
while ((p != NULL) && ((p->dev != dev) || (p->block != block)))
{
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
ffc11778: 40 9e 00 0c bne- cr7,ffc11784 <rtems_bdbuf_read+0x2b0> <== NOT EXECUTED
ffc1177c: 7f 9a 58 40 cmplw cr7,r26,r11 <== NOT EXECUTED
ffc11780: 41 9d ff 68 bgt+ cr7,ffc116e8 <rtems_bdbuf_read+0x214> <== NOT EXECUTED
{
p = p->avl.right;
}
else
{
p = p->avl.left;
ffc11784: 81 29 00 08 lwz r9,8(r9) <== NOT EXECUTED
ffc11788: 4b ff ff 64 b ffc116ec <rtems_bdbuf_read+0x218> <== NOT EXECUTED
dev_t dev,
rtems_blkdev_bnum block)
{
rtems_bdbuf_buffer* p = *root;
while ((p != NULL) && ((p->dev != dev) || (p->block != block)))
ffc1178c: 7f 1a 58 00 cmpw cr6,r26,r11
ffc11790: 40 9a ff 50 bne+ cr6,ffc116e0 <rtems_bdbuf_read+0x20c> <== NEVER TAKEN
ffc11794: 80 09 00 20 lwz r0,32(r9)
ffc11798: 7f 9b 00 00 cmpw cr7,r27,r0
ffc1179c: 41 be ff ac beq- cr7,ffc11748 <rtems_bdbuf_read+0x274> <== NEVER TAKEN
{
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
ffc117a0: 7f 9b 00 40 cmplw cr7,r27,r0
ffc117a4: 41 bd ff 44 bgt- cr7,ffc116e8 <rtems_bdbuf_read+0x214> <== ALWAYS TAKEN
{
p = p->avl.right;
}
else
{
p = p->avl.left;
ffc117a8: 81 29 00 08 lwz r9,8(r9) <== NOT EXECUTED
ffc117ac: 4b ff ff 40 b ffc116ec <rtems_bdbuf_read+0x218> <== NOT EXECUTED
req->bufs [0].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
switch (bd->state)
ffc117b0: 82 b9 00 10 lwz r21,16(r25)
ffc117b4: 4b ff ff 98 b ffc1174c <rtems_bdbuf_read+0x278>
rtems_bdbuf_lock_cache ();
rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
if (req->bufnum > 0)
{
sc = rtems_bdbuf_execute_transfer_request (dd, req, true);
ffc117b8: 80 9f 00 10 lwz r4,16(r31)
ffc117bc: 7f 25 cb 78 mr r5,r25
ffc117c0: 38 c0 00 01 li r6,1
ffc117c4: 38 64 00 08 addi r3,r4,8
ffc117c8: 38 84 00 28 addi r4,r4,40
ffc117cc: 4b ff e7 e1 bl ffc0ffac <rtems_bdbuf_execute_transfer_request.isra.9>
if (sc == RTEMS_SUCCESSFUL)
ffc117d0: 2c 03 00 00 cmpwi r3,0
ffc117d4: 41 82 00 40 beq- ffc11814 <rtems_bdbuf_read+0x340>
}
*bd_ptr = bd;
}
else
*bd_ptr = NULL;
ffc117d8: 38 00 00 00 li r0,0
ffc117dc: 90 1d 00 00 stw r0,0(r29)
ffc117e0: 7c 77 1b 78 mr r23,r3
rtems_bdbuf_unlock_cache ();
ffc117e4: 4b ff da 41 bl ffc0f224 <rtems_bdbuf_unlock_cache>
rtems_bdbuf_release_disk (dd);
ffc117e8: 80 7f 00 10 lwz r3,16(r31)
ffc117ec: 4b ff da b1 bl ffc0f29c <rtems_bdbuf_release_disk>
return sc;
ffc117f0: 4b ff fd 60 b ffc11550 <rtems_bdbuf_read+0x7c>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc117f4: 38 00 00 04 li r0,4
ffc117f8: 90 16 00 28 stw r0,40(r22)
{
rtems_bdbuf_show_users ("read", bd);
rtems_bdbuf_show_usage ();
}
*bd_ptr = bd;
ffc117fc: 92 dd 00 00 stw r22,0(r29)
ffc11800: 4b ff ff e4 b ffc117e4 <rtems_bdbuf_read+0x310>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc11804: 38 00 00 03 li r0,3
ffc11808: 90 16 00 28 stw r0,40(r22)
{
rtems_bdbuf_show_users ("read", bd);
rtems_bdbuf_show_usage ();
}
*bd_ptr = bd;
ffc1180c: 92 dd 00 00 stw r22,0(r29)
ffc11810: 4b ff ff d4 b ffc117e4 <rtems_bdbuf_read+0x310>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
ffc11814: 7e c3 b3 78 mr r3,r22
ffc11818: 4b ff 99 91 bl ffc0b1a8 <_Chain_Extract>
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
ffc1181c: 81 36 00 30 lwz r9,48(r22)
ffc11820: 80 09 00 0c lwz r0,12(r9)
ffc11824: 30 00 00 01 addic r0,r0,1
ffc11828: 90 09 00 0c stw r0,12(r9)
ffc1182c: 4b ff ff 28 b ffc11754 <rtems_bdbuf_read+0x280>
ffc11830 <rtems_bdbuf_release>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release (rtems_bdbuf_buffer *bd)
{
ffc11830: 94 21 ff f0 stwu r1,-16(r1)
ffc11834: 7c 08 02 a6 mflr r0
ffc11838: 93 c1 00 08 stw r30,8(r1)
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
ffc1183c: 3f c0 00 00 lis r30,0
ffc11840: 3b de 2a 08 addi r30,r30,10760
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release (rtems_bdbuf_buffer *bd)
{
ffc11844: 90 01 00 14 stw r0,20(r1)
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
ffc11848: 88 1e 00 88 lbz r0,136(r30)
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release (rtems_bdbuf_buffer *bd)
{
ffc1184c: 93 e1 00 0c stw r31,12(r1)
ffc11850: 7c 7f 1b 78 mr r31,r3
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
ffc11854: 2f 80 00 00 cmpwi cr7,r0,0
return RTEMS_NOT_CONFIGURED;
ffc11858: 38 60 00 16 li r3,22
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
ffc1185c: 41 9e 00 3c beq- cr7,ffc11898 <rtems_bdbuf_release+0x68><== NEVER TAKEN
return RTEMS_NOT_CONFIGURED;
if (bd == NULL)
ffc11860: 2f 9f 00 00 cmpwi cr7,r31,0
ffc11864: 41 9e 00 4c beq- cr7,ffc118b0 <rtems_bdbuf_release+0x80><== NEVER TAKEN
if (rtems_bdbuf_tracer)
{
printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);
rtems_bdbuf_show_users (kind, bd);
}
rtems_bdbuf_lock_cache();
ffc11868: 4b ff d7 31 bl ffc0ef98 <rtems_bdbuf_lock_cache>
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
ffc1186c: 80 1f 00 28 lwz r0,40(r31)
ffc11870: 2f 80 00 04 cmpwi cr7,r0,4
ffc11874: 41 9e 00 70 beq- cr7,ffc118e4 <rtems_bdbuf_release+0xb4>
ffc11878: 2b 80 00 04 cmplwi cr7,r0,4
ffc1187c: 40 9d 00 50 ble- cr7,ffc118cc <rtems_bdbuf_release+0x9c>
ffc11880: 2b 80 00 06 cmplwi cr7,r0,6
ffc11884: 41 9d 00 50 bgt- cr7,ffc118d4 <rtems_bdbuf_release+0xa4><== NEVER TAKEN
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
rtems_bdbuf_add_to_lru_list_after_access (bd);
break;
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
ffc11888: 7f e3 fb 78 mr r3,r31
ffc1188c: 4b ff e4 45 bl ffc0fcd0 <rtems_bdbuf_discard_buffer_after_access>
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
ffc11890: 4b ff d9 95 bl ffc0f224 <rtems_bdbuf_unlock_cache>
return RTEMS_SUCCESSFUL;
ffc11894: 38 60 00 00 li r3,0
}
ffc11898: 80 01 00 14 lwz r0,20(r1)
ffc1189c: 83 c1 00 08 lwz r30,8(r1)
ffc118a0: 7c 08 03 a6 mtlr r0
ffc118a4: 83 e1 00 0c lwz r31,12(r1)
ffc118a8: 38 21 00 10 addi r1,r1,16
ffc118ac: 4e 80 00 20 blr
ffc118b0: 80 01 00 14 lwz r0,20(r1) <== NOT EXECUTED
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
return RTEMS_NOT_CONFIGURED;
if (bd == NULL)
return RTEMS_INVALID_ADDRESS;
ffc118b4: 38 60 00 09 li r3,9 <== NOT EXECUTED
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
return RTEMS_SUCCESSFUL;
}
ffc118b8: 83 c1 00 08 lwz r30,8(r1) <== NOT EXECUTED
ffc118bc: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc118c0: 83 e1 00 0c lwz r31,12(r1) <== NOT EXECUTED
ffc118c4: 38 21 00 10 addi r1,r1,16 <== NOT EXECUTED
ffc118c8: 4e 80 00 20 blr <== NOT EXECUTED
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
ffc118cc: 2f 80 00 03 cmpwi cr7,r0,3
ffc118d0: 41 9e 00 20 beq- cr7,ffc118f0 <rtems_bdbuf_release+0xc0><== ALWAYS TAKEN
break;
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_0);
ffc118d4: 3c 80 42 00 lis r4,16896 <== NOT EXECUTED
ffc118d8: 80 7f 00 28 lwz r3,40(r31) <== NOT EXECUTED
ffc118dc: 60 84 00 1c ori r4,r4,28 <== NOT EXECUTED
ffc118e0: 4b ff d7 41 bl ffc0f020 <rtems_bdbuf_fatal> <== NOT EXECUTED
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
break;
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
ffc118e4: 7f e3 fb 78 mr r3,r31
ffc118e8: 4b ff dc f9 bl ffc0f5e0 <rtems_bdbuf_add_to_modified_list_after_access>
break;
ffc118ec: 4b ff ff a4 b ffc11890 <rtems_bdbuf_release+0x60>
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
ffc118f0: 81 3f 00 30 lwz r9,48(r31)
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
ffc118f4: 38 7e 00 44 addi r3,r30,68
ffc118f8: 7f e4 fb 78 mr r4,r31
ffc118fc: 81 69 00 0c lwz r11,12(r9)
ffc11900: 38 0b ff ff addi r0,r11,-1
ffc11904: 90 09 00 0c stw r0,12(r9)
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc11908: 38 00 00 02 li r0,2
ffc1190c: 90 1f 00 28 stw r0,40(r31)
ffc11910: 4b ff 98 69 bl ffc0b178 <_Chain_Append>
rtems_bdbuf_add_to_lru_list_after_access (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_group_release (bd);
rtems_bdbuf_make_cached_and_add_to_lru_list (bd);
if (bd->waiters)
ffc11914: 80 1f 00 2c lwz r0,44(r31)
ffc11918: 2f 80 00 00 cmpwi cr7,r0,0
ffc1191c: 41 9e 00 10 beq- cr7,ffc1192c <rtems_bdbuf_release+0xfc>
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
ffc11920: 38 7e 00 68 addi r3,r30,104
ffc11924: 4b ff dc 79 bl ffc0f59c <rtems_bdbuf_wake>
ffc11928: 4b ff ff 68 b ffc11890 <rtems_bdbuf_release+0x60>
else
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
ffc1192c: 38 7e 00 78 addi r3,r30,120
ffc11930: 4b ff dc 6d bl ffc0f59c <rtems_bdbuf_wake>
ffc11934: 4b ff ff 5c b ffc11890 <rtems_bdbuf_release+0x60>
ffc0f29c <rtems_bdbuf_release_disk>:
return RTEMS_SUCCESSFUL;
}
static void
rtems_bdbuf_release_disk (rtems_disk_device *dd)
{
ffc0f29c: 94 21 ff f8 stwu r1,-8(r1)
ffc0f2a0: 7c 08 02 a6 mflr r0
ffc0f2a4: 90 01 00 0c stw r0,12(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_disk_release (dd);
ffc0f2a8: 4b ff 5a 5d bl ffc04d04 <rtems_disk_release>
if (sc != RTEMS_SUCCESSFUL)
ffc0f2ac: 2f 83 00 00 cmpwi cr7,r3,0
ffc0f2b0: 40 9e 00 14 bne- cr7,ffc0f2c4 <rtems_bdbuf_release_disk+0x28><== NEVER TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_DISK_REL);
}
ffc0f2b4: 80 01 00 0c lwz r0,12(r1)
ffc0f2b8: 38 21 00 08 addi r1,r1,8
ffc0f2bc: 7c 08 03 a6 mtlr r0
ffc0f2c0: 4e 80 00 20 blr
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_disk_release (dd);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_DISK_REL);
ffc0f2c4: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0f2c8: 60 63 00 1f ori r3,r3,31 <== NOT EXECUTED
ffc0f2cc: 4b ff b7 e5 bl ffc0aab0 <rtems_fatal_error_occurred> <== NOT EXECUTED
ffc11938 <rtems_bdbuf_release_modified>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release_modified (rtems_bdbuf_buffer *bd)
{
ffc11938: 94 21 ff f0 stwu r1,-16(r1)
ffc1193c: 7c 08 02 a6 mflr r0
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
ffc11940: 3d 20 00 00 lis r9,0
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release_modified (rtems_bdbuf_buffer *bd)
{
ffc11944: 90 01 00 14 stw r0,20(r1)
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
ffc11948: 88 09 2a 90 lbz r0,10896(r9)
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release_modified (rtems_bdbuf_buffer *bd)
{
ffc1194c: 93 e1 00 0c stw r31,12(r1)
ffc11950: 7c 7f 1b 78 mr r31,r3
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
ffc11954: 2f 80 00 00 cmpwi cr7,r0,0
return RTEMS_NOT_CONFIGURED;
ffc11958: 38 60 00 16 li r3,22
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
ffc1195c: 41 9e 00 4c beq- cr7,ffc119a8 <rtems_bdbuf_release_modified+0x70><== NEVER TAKEN
return RTEMS_NOT_CONFIGURED;
if (bd == NULL)
ffc11960: 2f 9f 00 00 cmpwi cr7,r31,0
ffc11964: 41 9e 00 58 beq- cr7,ffc119bc <rtems_bdbuf_release_modified+0x84><== NEVER TAKEN
if (rtems_bdbuf_tracer)
{
printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);
rtems_bdbuf_show_users (kind, bd);
}
rtems_bdbuf_lock_cache();
ffc11968: 4b ff d6 31 bl ffc0ef98 <rtems_bdbuf_lock_cache>
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release modified");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
ffc1196c: 80 1f 00 28 lwz r0,40(r31)
ffc11970: 2b 80 00 03 cmplwi cr7,r0,3
ffc11974: 41 9c 00 14 blt- cr7,ffc11988 <rtems_bdbuf_release_modified+0x50><== NEVER TAKEN
ffc11978: 2b 80 00 05 cmplwi cr7,r0,5
ffc1197c: 40 9d 00 58 ble- cr7,ffc119d4 <rtems_bdbuf_release_modified+0x9c>
ffc11980: 2f 80 00 06 cmpwi cr7,r0,6
ffc11984: 41 9e 00 14 beq- cr7,ffc11998 <rtems_bdbuf_release_modified+0x60><== ALWAYS TAKEN
break;
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_6);
ffc11988: 3c 80 42 00 lis r4,16896 <== NOT EXECUTED
ffc1198c: 80 7f 00 28 lwz r3,40(r31) <== NOT EXECUTED
ffc11990: 60 84 00 04 ori r4,r4,4 <== NOT EXECUTED
ffc11994: 4b ff d6 8d bl ffc0f020 <rtems_bdbuf_fatal> <== NOT EXECUTED
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
break;
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
ffc11998: 7f e3 fb 78 mr r3,r31
ffc1199c: 4b ff e3 35 bl ffc0fcd0 <rtems_bdbuf_discard_buffer_after_access>
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
ffc119a0: 4b ff d8 85 bl ffc0f224 <rtems_bdbuf_unlock_cache>
return RTEMS_SUCCESSFUL;
ffc119a4: 38 60 00 00 li r3,0
}
ffc119a8: 80 01 00 14 lwz r0,20(r1)
ffc119ac: 83 e1 00 0c lwz r31,12(r1)
ffc119b0: 38 21 00 10 addi r1,r1,16
ffc119b4: 7c 08 03 a6 mtlr r0
ffc119b8: 4e 80 00 20 blr
ffc119bc: 80 01 00 14 lwz r0,20(r1) <== NOT EXECUTED
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
return RTEMS_NOT_CONFIGURED;
if (bd == NULL)
return RTEMS_INVALID_ADDRESS;
ffc119c0: 38 60 00 09 li r3,9 <== NOT EXECUTED
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
return RTEMS_SUCCESSFUL;
}
ffc119c4: 83 e1 00 0c lwz r31,12(r1) <== NOT EXECUTED
ffc119c8: 38 21 00 10 addi r1,r1,16 <== NOT EXECUTED
ffc119cc: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc119d0: 4e 80 00 20 blr <== NOT EXECUTED
switch (bd->state)
{
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
ffc119d4: 7f e3 fb 78 mr r3,r31
ffc119d8: 4b ff dc 09 bl ffc0f5e0 <rtems_bdbuf_add_to_modified_list_after_access>
break;
ffc119dc: 4b ff ff c4 b ffc119a0 <rtems_bdbuf_release_modified+0x68>
ffc0f83c <rtems_bdbuf_remove_from_tree>:
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
ffc0f83c: 94 21 ff 58 stwu r1,-168(r1)
ffc0f840: 7c 08 02 a6 mflr r0
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
ffc0f844: 38 80 00 00 li r4,0
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
ffc0f848: 93 21 00 8c stw r25,140(r1)
const rtems_bdbuf_buffer* node)
{
dev_t dev = node->dev;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
ffc0f84c: 3f 20 00 00 lis r25,0
ffc0f850: 3b 39 2a 08 addi r25,r25,10760
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
ffc0f854: 90 01 00 ac stw r0,172(r1)
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
ffc0f858: 38 a0 00 80 li r5,128
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
ffc0f85c: 93 61 00 94 stw r27,148(r1)
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
ffc0f860: 3b 61 00 08 addi r27,r1,8
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
ffc0f864: 93 e1 00 a4 stw r31,164(r1)
const rtems_bdbuf_buffer* node)
{
dev_t dev = node->dev;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
ffc0f868: 83 f9 00 40 lwz r31,64(r25)
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
ffc0f86c: 93 41 00 90 stw r26,144(r1)
ffc0f870: 7c 7a 1b 78 mr r26,r3
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
ffc0f874: 7f 63 db 78 mr r3,r27
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
ffc0f878: 93 81 00 98 stw r28,152(r1)
ffc0f87c: 93 a1 00 9c stw r29,156(r1)
ffc0f880: 93 c1 00 a0 stw r30,160(r1)
*/
static int
rtems_bdbuf_avl_remove(rtems_bdbuf_buffer** root,
const rtems_bdbuf_buffer* node)
{
dev_t dev = node->dev;
ffc0f884: 83 ba 00 1c lwz r29,28(r26)
ffc0f888: 83 da 00 18 lwz r30,24(r26)
rtems_blkdev_bnum block = node->block;
ffc0f88c: 83 9a 00 20 lwz r28,32(r26)
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
ffc0f890: 48 00 99 a1 bl ffc19230 <memset>
while (p != NULL)
ffc0f894: 2f 9f 00 00 cmpwi cr7,r31,0
ffc0f898: 41 9e 00 64 beq- cr7,ffc0f8fc <rtems_bdbuf_remove_from_tree+0xc0><== NEVER TAKEN
ffc0f89c: 7f 6b db 78 mr r11,r27
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
{
p->avl.cache = 1;
ffc0f8a0: 39 00 00 01 li r8,1
p = p->avl.right;
}
else if ((p->dev != dev) || (p->block != block))
{
p->avl.cache = -1;
ffc0f8a4: 38 e0 ff ff li r7,-1
while (p != NULL)
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
ffc0f8a8: 80 1f 00 18 lwz r0,24(r31)
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
{
*buf_prev++ = p;
ffc0f8ac: 39 2b 00 04 addi r9,r11,4
ffc0f8b0: 93 eb 00 00 stw r31,0(r11)
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
ffc0f8b4: 7f 9e 00 40 cmplw cr7,r30,r0
ffc0f8b8: 81 5f 00 1c lwz r10,28(r31)
ffc0f8bc: 41 9d 00 14 bgt- cr7,ffc0f8d0 <rtems_bdbuf_remove_from_tree+0x94><== NEVER TAKEN
ffc0f8c0: 7f 9e 00 00 cmpw cr7,r30,r0
ffc0f8c4: 40 9e 00 24 bne- cr7,ffc0f8e8 <rtems_bdbuf_remove_from_tree+0xac><== NEVER TAKEN
ffc0f8c8: 7f 1d 50 40 cmplw cr6,r29,r10
ffc0f8cc: 40 99 00 1c ble- cr6,ffc0f8e8 <rtems_bdbuf_remove_from_tree+0xac><== ALWAYS TAKEN
{
p->avl.cache = 1;
ffc0f8d0: 99 1f 00 10 stb r8,16(r31)
p = p->avl.right;
ffc0f8d4: 83 ff 00 0c lwz r31,12(r31)
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
ffc0f8d8: 2f 9f 00 00 cmpwi cr7,r31,0
ffc0f8dc: 41 9e 00 20 beq- cr7,ffc0f8fc <rtems_bdbuf_remove_from_tree+0xc0><== NEVER TAKEN
{
*buf_prev++ = p;
ffc0f8e0: 7d 2b 4b 78 mr r11,r9
ffc0f8e4: 4b ff ff c4 b ffc0f8a8 <rtems_bdbuf_remove_from_tree+0x6c>
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
ffc0f8e8: 41 9e 00 24 beq- cr7,ffc0f90c <rtems_bdbuf_remove_from_tree+0xd0><== ALWAYS TAKEN
p->avl.cache = 1;
p = p->avl.right;
}
else if ((p->dev != dev) || (p->block != block))
{
p->avl.cache = -1;
ffc0f8ec: 98 ff 00 10 stb r7,16(r31)
p = p->avl.left;
ffc0f8f0: 83 ff 00 08 lwz r31,8(r31)
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
ffc0f8f4: 2f 9f 00 00 cmpwi cr7,r31,0
ffc0f8f8: 40 9e ff e8 bne+ cr7,ffc0f8e0 <rtems_bdbuf_remove_from_tree+0xa4><== ALWAYS TAKEN
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
if (rtems_bdbuf_avl_remove (&bdbuf_cache.tree, bd) != 0)
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_TREE_RM);
ffc0f8fc: 3c 80 42 00 lis r4,16896 <== NOT EXECUTED
ffc0f900: 80 7a 00 28 lwz r3,40(r26) <== NOT EXECUTED
ffc0f904: 60 84 00 09 ori r4,r4,9 <== NOT EXECUTED
ffc0f908: 4b ff f7 19 bl ffc0f020 <rtems_bdbuf_fatal> <== NOT EXECUTED
while (p != NULL)
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
ffc0f90c: 7f 9d 50 00 cmpw cr7,r29,r10
ffc0f910: 40 9e ff dc bne+ cr7,ffc0f8ec <rtems_bdbuf_remove_from_tree+0xb0><== NEVER TAKEN
ffc0f914: 80 1f 00 20 lwz r0,32(r31)
ffc0f918: 7f 9c 00 40 cmplw cr7,r28,r0
ffc0f91c: 41 bd ff b4 bgt- cr7,ffc0f8d0 <rtems_bdbuf_remove_from_tree+0x94>
{
p->avl.cache = 1;
p = p->avl.right;
}
else if ((p->dev != dev) || (p->block != block))
ffc0f920: 7f 9c 00 00 cmpw cr7,r28,r0
ffc0f924: 40 9e ff c8 bne+ cr7,ffc0f8ec <rtems_bdbuf_remove_from_tree+0xb0>
}
q = p;
buf_prev--;
if (buf_prev > buf_stack)
ffc0f928: 7f 9b 58 40 cmplw cr7,r27,r11
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
{
*buf_prev++ = p;
ffc0f92c: 7d 24 4b 78 mr r4,r9
{
p = *(buf_prev - 1);
}
else
{
p = NULL;
ffc0f930: 38 c0 00 00 li r6,0
}
q = p;
buf_prev--;
if (buf_prev > buf_stack)
ffc0f934: 40 9c 00 08 bge- cr7,ffc0f93c <rtems_bdbuf_remove_from_tree+0x100>
{
p = *(buf_prev - 1);
ffc0f938: 80 c9 ff f8 lwz r6,-8(r9)
{
p = NULL;
}
/* at this moment q - is a node to delete, p is q's parent */
if (q->avl.right == NULL)
ffc0f93c: 80 ff 00 0c lwz r7,12(r31)
ffc0f940: 2f 87 00 00 cmpwi cr7,r7,0
ffc0f944: 41 9e 02 f0 beq- cr7,ffc0fc34 <rtems_bdbuf_remove_from_tree+0x3f8>
{
rtems_bdbuf_buffer **t;
r = q->avl.right;
if (r->avl.left == NULL)
ffc0f948: 81 47 00 08 lwz r10,8(r7)
ffc0f94c: 7c eb 3b 78 mr r11,r7
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
ffc0f950: 39 00 ff ff li r8,-1
{
rtems_bdbuf_buffer **t;
r = q->avl.right;
if (r->avl.left == NULL)
ffc0f954: 2f 8a 00 00 cmpwi cr7,r10,0
ffc0f958: 40 be 00 10 bne+ cr7,ffc0f968 <rtems_bdbuf_remove_from_tree+0x12c>
ffc0f95c: 48 00 02 f0 b ffc0fc4c <rtems_bdbuf_remove_from_tree+0x410>
else
{
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
ffc0f960: 7d 4b 53 78 mr r11,r10
ffc0f964: 7c 0a 03 78 mr r10,r0
ffc0f968: 80 0a 00 08 lwz r0,8(r10)
{
*buf_prev++ = r = s;
ffc0f96c: 91 69 00 00 stw r11,0(r9)
ffc0f970: 39 29 00 04 addi r9,r9,4
else
{
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
ffc0f974: 2f 80 00 00 cmpwi cr7,r0,0
{
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
ffc0f978: 99 0b 00 10 stb r8,16(r11)
else
{
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
ffc0f97c: 40 9e ff e4 bne+ cr7,ffc0f960 <rtems_bdbuf_remove_from_tree+0x124>
}
s->avl.left = q->avl.left;
r->avl.left = s->avl.right;
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
ffc0f980: 88 1f 00 11 lbz r0,17(r31)
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
ffc0f984: 80 bf 00 08 lwz r5,8(r31)
r->avl.left = s->avl.right;
ffc0f988: 81 0a 00 0c lwz r8,12(r10)
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
ffc0f98c: 98 0a 00 11 stb r0,17(r10)
s->avl.cache = 1;
ffc0f990: 38 00 00 01 li r0,1
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
ffc0f994: 90 aa 00 08 stw r5,8(r10)
r->avl.left = s->avl.right;
s->avl.right = q->avl.right;
ffc0f998: 90 ea 00 0c stw r7,12(r10)
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
r->avl.left = s->avl.right;
ffc0f99c: 91 0b 00 08 stw r8,8(r11)
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
s->avl.cache = 1;
ffc0f9a0: 98 0a 00 10 stb r0,16(r10)
*t = q = s;
ffc0f9a4: 91 44 ff fc stw r10,-4(r4)
}
}
if (p != NULL)
ffc0f9a8: 2f 86 00 00 cmpwi cr7,r6,0
ffc0f9ac: 41 9e 02 80 beq- cr7,ffc0fc2c <rtems_bdbuf_remove_from_tree+0x3f0>
{
if (p->avl.cache == -1)
ffc0f9b0: 88 06 00 10 lbz r0,16(r6)
ffc0f9b4: 2f 80 00 ff cmpwi cr7,r0,255
ffc0f9b8: 41 9e 02 18 beq- cr7,ffc0fbd0 <rtems_bdbuf_remove_from_tree+0x394>
{
p->avl.left = q;
}
else
{
p->avl.right = q;
ffc0f9bc: 91 46 00 0c stw r10,12(r6)
modified = true;
while (modified)
{
if (buf_prev > buf_stack)
ffc0f9c0: 7f 9b 48 40 cmplw cr7,r27,r9
ffc0f9c4: 40 9c 00 78 bge- cr7,ffc0fa3c <rtems_bdbuf_remove_from_tree+0x200>
p->avl.right = q;
}
}
else
{
*root = q;
ffc0f9c8: 7d 2a 4b 78 mr r10,r9
ffc0f9cc: 85 2a ff fc lwzu r9,-4(r10)
{
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
ffc0f9d0: 21 7b 00 03 subfic r11,r27,3
else
{
break;
}
if (p->avl.cache == -1)
ffc0f9d4: 38 a0 ff ff li r5,-1
{
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
ffc0f9d8: 7d 6b 52 14 add r11,r11,r10
p->avl.right = q;
}
}
else
{
*root = q;
ffc0f9dc: 88 09 00 10 lbz r0,16(r9)
{
p->avl.left = p1->avl.right;
p1->avl.right = p;
if (p1->avl.bal == 0)
{
p1->avl.bal = 1;
ffc0f9e0: 55 6b f0 be rlwinm r11,r11,30,2,31
ffc0f9e4: 39 6b 00 01 addi r11,r11,1
p->avl.right = q;
}
}
else
{
*root = q;
ffc0f9e8: 7c 00 07 74 extsb r0,r0
{
p->avl.left = p1->avl.right;
p1->avl.right = p;
if (p1->avl.bal == 0)
{
p1->avl.bal = 1;
ffc0f9ec: 7d 69 03 a6 mtctr r11
ffc0f9f0: 2f 80 ff ff cmpwi cr7,r0,-1
{
/* rebalance right branch */
switch (p->avl.bal)
{
case +1:
p->avl.bal = 0;
ffc0f9f4: 38 e0 00 00 li r7,0
{
p->avl.left = p1->avl.right;
p1->avl.right = p;
if (p1->avl.bal == 0)
{
p1->avl.bal = 1;
ffc0f9f8: 38 60 00 01 li r3,1
else
{
break;
}
if (p->avl.cache == -1)
ffc0f9fc: 41 9e 00 b8 beq- cr7,ffc0fab4 <rtems_bdbuf_remove_from_tree+0x278>
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
ffc0fa00: 88 09 00 11 lbz r0,17(r9)
ffc0fa04: 7c 00 07 75 extsb. r0,r0
ffc0fa08: 40 82 00 60 bne- ffc0fa68 <rtems_bdbuf_remove_from_tree+0x22c>
case +1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = -1;
ffc0fa0c: 98 a9 00 11 stb r5,17(r9)
ffc0fa10: 7d 2b 4b 78 mr r11,r9
modified = false;
ffc0fa14: 39 00 00 00 li r8,0
default:
break;
}
}
if (buf_prev > buf_stack)
ffc0fa18: 42 40 00 6c bdz- ffc0fa84 <rtems_bdbuf_remove_from_tree+0x248>
{
q = *(buf_prev - 1);
ffc0fa1c: 85 2a ff fc lwzu r9,-4(r10)
if (q->avl.cache == -1)
ffc0fa20: 88 09 00 10 lbz r0,16(r9)
ffc0fa24: 7c 00 07 74 extsb r0,r0
ffc0fa28: 2f 80 ff ff cmpwi cr7,r0,-1
ffc0fa2c: 41 9e 00 a4 beq- cr7,ffc0fad0 <rtems_bdbuf_remove_from_tree+0x294>
{
q->avl.left = p;
}
else
{
q->avl.right = p;
ffc0fa30: 91 69 00 0c stw r11,12(r9)
*root = q;
}
modified = true;
while (modified)
ffc0fa34: 2f 08 00 00 cmpwi cr6,r8,0
ffc0fa38: 40 9a ff c4 bne+ cr6,ffc0f9fc <rtems_bdbuf_remove_from_tree+0x1c0>
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
if (rtems_bdbuf_avl_remove (&bdbuf_cache.tree, bd) != 0)
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_TREE_RM);
}
ffc0fa3c: 80 01 00 ac lwz r0,172(r1)
ffc0fa40: 83 21 00 8c lwz r25,140(r1)
ffc0fa44: 7c 08 03 a6 mtlr r0
ffc0fa48: 83 41 00 90 lwz r26,144(r1)
ffc0fa4c: 83 61 00 94 lwz r27,148(r1)
ffc0fa50: 83 81 00 98 lwz r28,152(r1)
ffc0fa54: 83 a1 00 9c lwz r29,156(r1)
ffc0fa58: 83 c1 00 a0 lwz r30,160(r1)
ffc0fa5c: 83 e1 00 a4 lwz r31,164(r1)
ffc0fa60: 38 21 00 a8 addi r1,r1,168
ffc0fa64: 4e 80 00 20 blr
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
ffc0fa68: 2f 80 00 01 cmpwi cr7,r0,1
ffc0fa6c: 41 9e 00 7c beq- cr7,ffc0fae8 <rtems_bdbuf_remove_from_tree+0x2ac>
ffc0fa70: 2f 80 ff ff cmpwi cr7,r0,-1
ffc0fa74: 41 9e 00 84 beq- cr7,ffc0faf8 <rtems_bdbuf_remove_from_tree+0x2bc><== ALWAYS TAKEN
ffc0fa78: 7d 2b 4b 78 mr r11,r9 <== NOT EXECUTED
ffc0fa7c: 39 00 00 01 li r8,1 <== NOT EXECUTED
default:
break;
}
}
if (buf_prev > buf_stack)
ffc0fa80: 42 00 ff 9c bdnz+ ffc0fa1c <rtems_bdbuf_remove_from_tree+0x1e0><== NOT EXECUTED
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
if (rtems_bdbuf_avl_remove (&bdbuf_cache.tree, bd) != 0)
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_TREE_RM);
}
ffc0fa84: 80 01 00 ac lwz r0,172(r1)
q->avl.right = p;
}
}
else
{
*root = p;
ffc0fa88: 91 79 00 40 stw r11,64(r25)
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
if (rtems_bdbuf_avl_remove (&bdbuf_cache.tree, bd) != 0)
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_TREE_RM);
}
ffc0fa8c: 7c 08 03 a6 mtlr r0
ffc0fa90: 83 21 00 8c lwz r25,140(r1)
ffc0fa94: 83 41 00 90 lwz r26,144(r1)
ffc0fa98: 83 61 00 94 lwz r27,148(r1)
ffc0fa9c: 83 81 00 98 lwz r28,152(r1)
ffc0faa0: 83 a1 00 9c lwz r29,156(r1)
ffc0faa4: 83 c1 00 a0 lwz r30,160(r1)
ffc0faa8: 83 e1 00 a4 lwz r31,164(r1)
ffc0faac: 38 21 00 a8 addi r1,r1,168
ffc0fab0: 4e 80 00 20 blr
}
if (p->avl.cache == -1)
{
/* rebalance left branch */
switch (p->avl.bal)
ffc0fab4: 89 69 00 11 lbz r11,17(r9)
ffc0fab8: 7d 6b 07 75 extsb. r11,r11
ffc0fabc: 40 82 00 1c bne- ffc0fad8 <rtems_bdbuf_remove_from_tree+0x29c>
{
case -1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = 1;
ffc0fac0: 98 69 00 11 stb r3,17(r9)
ffc0fac4: 7d 2b 4b 78 mr r11,r9
modified = false;
ffc0fac8: 39 00 00 00 li r8,0
ffc0facc: 4b ff ff 4c b ffc0fa18 <rtems_bdbuf_remove_from_tree+0x1dc>
{
q = *(buf_prev - 1);
if (q->avl.cache == -1)
{
q->avl.left = p;
ffc0fad0: 91 69 00 08 stw r11,8(r9)
ffc0fad4: 4b ff ff 60 b ffc0fa34 <rtems_bdbuf_remove_from_tree+0x1f8>
}
if (p->avl.cache == -1)
{
/* rebalance left branch */
switch (p->avl.bal)
ffc0fad8: 2f 8b 00 01 cmpwi cr7,r11,1
ffc0fadc: 41 9e 00 7c beq- cr7,ffc0fb58 <rtems_bdbuf_remove_from_tree+0x31c>
ffc0fae0: 2f 8b ff ff cmpwi cr7,r11,-1
ffc0fae4: 40 9e ff 94 bne+ cr7,ffc0fa78 <rtems_bdbuf_remove_from_tree+0x23c><== NEVER TAKEN
{
/* rebalance right branch */
switch (p->avl.bal)
{
case +1:
p->avl.bal = 0;
ffc0fae8: 98 e9 00 11 stb r7,17(r9)
ffc0faec: 7d 2b 4b 78 mr r11,r9
ffc0faf0: 39 00 00 01 li r8,1
ffc0faf4: 4b ff ff 24 b ffc0fa18 <rtems_bdbuf_remove_from_tree+0x1dc>
p->avl.bal = -1;
modified = false;
break;
case -1:
p1 = p->avl.left;
ffc0faf8: 81 09 00 08 lwz r8,8(r9)
if (p1->avl.bal <= 0) /* simple LL-turn */
ffc0fafc: 88 08 00 11 lbz r0,17(r8)
ffc0fb00: 7c 0b 07 75 extsb. r11,r0
ffc0fb04: 40 81 00 80 ble- ffc0fb84 <rtems_bdbuf_remove_from_tree+0x348><== NEVER TAKEN
}
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
ffc0fb08: 81 68 00 0c lwz r11,12(r8)
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
ffc0fb0c: 38 c0 00 00 li r6,0
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
ffc0fb10: 88 0b 00 11 lbz r0,17(r11)
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
ffc0fb14: 80 8b 00 08 lwz r4,8(r11)
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
ffc0fb18: 68 00 00 ff xori r0,r0,255
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
ffc0fb1c: 91 0b 00 08 stw r8,8(r11)
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
ffc0fb20: 7c 00 00 34 cntlzw r0,r0
ffc0fb24: 54 00 d9 7e rlwinm r0,r0,27,5,31
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
ffc0fb28: 90 88 00 0c stw r4,12(r8)
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
ffc0fb2c: 98 09 00 11 stb r0,17(r9)
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
ffc0fb30: 88 0b 00 11 lbz r0,17(r11)
ffc0fb34: 2f 80 00 01 cmpwi cr7,r0,1
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
ffc0fb38: 80 0b 00 0c lwz r0,12(r11)
p2->avl.right = p;
ffc0fb3c: 91 2b 00 0c stw r9,12(r11)
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
ffc0fb40: 90 09 00 08 stw r0,8(r9)
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
ffc0fb44: 41 9e 00 60 beq- cr7,ffc0fba4 <rtems_bdbuf_remove_from_tree+0x368>
ffc0fb48: 98 c8 00 11 stb r6,17(r8)
p = p2;
p2->avl.bal = 0;
ffc0fb4c: 39 00 00 01 li r8,1
ffc0fb50: 98 eb 00 11 stb r7,17(r11)
ffc0fb54: 4b ff fe c4 b ffc0fa18 <rtems_bdbuf_remove_from_tree+0x1dc>
p->avl.bal = 1;
modified = false;
break;
case +1:
p1 = p->avl.right;
ffc0fb58: 81 69 00 0c lwz r11,12(r9)
if (p1->avl.bal >= 0) /* simple RR-turn */
ffc0fb5c: 89 0b 00 11 lbz r8,17(r11)
ffc0fb60: 7d 06 07 75 extsb. r6,r8
ffc0fb64: 41 80 00 74 blt- ffc0fbd8 <rtems_bdbuf_remove_from_tree+0x39c><== NEVER TAKEN
{
p->avl.right = p1->avl.left;
ffc0fb68: 81 0b 00 08 lwz r8,8(r11)
p1->avl.left = p;
ffc0fb6c: 91 2b 00 08 stw r9,8(r11)
case +1:
p1 = p->avl.right;
if (p1->avl.bal >= 0) /* simple RR-turn */
{
p->avl.right = p1->avl.left;
ffc0fb70: 91 09 00 0c stw r8,12(r9)
p1->avl.left = p;
if (p1->avl.bal == 0)
ffc0fb74: 40 82 00 38 bne- ffc0fbac <rtems_bdbuf_remove_from_tree+0x370>
{
p1->avl.bal = -1;
ffc0fb78: 98 0b 00 11 stb r0,17(r11)
modified = false;
ffc0fb7c: 39 00 00 00 li r8,0
ffc0fb80: 4b ff fe 98 b ffc0fa18 <rtems_bdbuf_remove_from_tree+0x1dc>
case -1:
p1 = p->avl.left;
if (p1->avl.bal <= 0) /* simple LL-turn */
{
p->avl.left = p1->avl.right;
ffc0fb84: 80 08 00 0c lwz r0,12(r8) <== NOT EXECUTED
p1->avl.right = p;
ffc0fb88: 91 28 00 0c stw r9,12(r8) <== NOT EXECUTED
case -1:
p1 = p->avl.left;
if (p1->avl.bal <= 0) /* simple LL-turn */
{
p->avl.left = p1->avl.right;
ffc0fb8c: 90 09 00 08 stw r0,8(r9) <== NOT EXECUTED
p1->avl.right = p;
if (p1->avl.bal == 0)
ffc0fb90: 40 82 00 2c bne- ffc0fbbc <rtems_bdbuf_remove_from_tree+0x380><== NOT EXECUTED
{
p1->avl.bal = 1;
ffc0fb94: 98 68 00 11 stb r3,17(r8) <== NOT EXECUTED
ffc0fb98: 7d 0b 43 78 mr r11,r8 <== NOT EXECUTED
modified = false;
ffc0fb9c: 39 00 00 00 li r8,0 <== NOT EXECUTED
ffc0fba0: 4b ff fe 78 b ffc0fa18 <rtems_bdbuf_remove_from_tree+0x1dc><== NOT EXECUTED
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
ffc0fba4: 38 c0 ff ff li r6,-1
ffc0fba8: 4b ff ff a0 b ffc0fb48 <rtems_bdbuf_remove_from_tree+0x30c>
p1->avl.bal = -1;
modified = false;
}
else
{
p->avl.bal = 0;
ffc0fbac: 98 e9 00 11 stb r7,17(r9)
p1->avl.bal = 0;
ffc0fbb0: 39 00 00 01 li r8,1
ffc0fbb4: 98 eb 00 11 stb r7,17(r11)
ffc0fbb8: 4b ff fe 60 b ffc0fa18 <rtems_bdbuf_remove_from_tree+0x1dc>
p1->avl.bal = 1;
modified = false;
}
else
{
p->avl.bal = 0;
ffc0fbbc: 98 e9 00 11 stb r7,17(r9) <== NOT EXECUTED
p1->avl.bal = 0;
ffc0fbc0: 7d 0b 43 78 mr r11,r8 <== NOT EXECUTED
ffc0fbc4: 98 e8 00 11 stb r7,17(r8) <== NOT EXECUTED
ffc0fbc8: 39 00 00 01 li r8,1 <== NOT EXECUTED
ffc0fbcc: 4b ff fe 4c b ffc0fa18 <rtems_bdbuf_remove_from_tree+0x1dc><== NOT EXECUTED
if (p != NULL)
{
if (p->avl.cache == -1)
{
p->avl.left = q;
ffc0fbd0: 91 46 00 08 stw r10,8(r6)
ffc0fbd4: 4b ff fd ec b ffc0f9c0 <rtems_bdbuf_remove_from_tree+0x184>
}
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
ffc0fbd8: 80 cb 00 08 lwz r6,8(r11) <== NOT EXECUTED
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
ffc0fbdc: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc0fbe0: 88 86 00 11 lbz r4,17(r6) <== NOT EXECUTED
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
ffc0fbe4: 81 06 00 0c lwz r8,12(r6) <== NOT EXECUTED
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
ffc0fbe8: 2f 84 00 01 cmpwi cr7,r4,1 <== NOT EXECUTED
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
ffc0fbec: 91 66 00 0c stw r11,12(r6) <== NOT EXECUTED
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
ffc0fbf0: 91 0b 00 08 stw r8,8(r11) <== NOT EXECUTED
p2->avl.right = p1;
p->avl.right = p2->avl.left;
ffc0fbf4: 81 06 00 08 lwz r8,8(r6) <== NOT EXECUTED
p2->avl.left = p;
ffc0fbf8: 91 26 00 08 stw r9,8(r6) <== NOT EXECUTED
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
ffc0fbfc: 91 09 00 0c stw r8,12(r9) <== NOT EXECUTED
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
ffc0fc00: 41 9e 00 70 beq- cr7,ffc0fc70 <rtems_bdbuf_remove_from_tree+0x434><== NOT EXECUTED
ffc0fc04: 98 09 00 11 stb r0,17(r9) <== NOT EXECUTED
if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
p = p2;
p2->avl.bal = 0;
ffc0fc08: 39 00 00 01 li r8,1 <== NOT EXECUTED
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
ffc0fc0c: 88 06 00 11 lbz r0,17(r6) <== NOT EXECUTED
ffc0fc10: 68 00 00 ff xori r0,r0,255 <== NOT EXECUTED
ffc0fc14: 7c 00 00 34 cntlzw r0,r0 <== NOT EXECUTED
ffc0fc18: 54 00 d9 7e rlwinm r0,r0,27,5,31 <== NOT EXECUTED
ffc0fc1c: 98 0b 00 11 stb r0,17(r11) <== NOT EXECUTED
p = p2;
p2->avl.bal = 0;
ffc0fc20: 7c cb 33 78 mr r11,r6 <== NOT EXECUTED
ffc0fc24: 98 e6 00 11 stb r7,17(r6) <== NOT EXECUTED
ffc0fc28: 4b ff fd f0 b ffc0fa18 <rtems_bdbuf_remove_from_tree+0x1dc><== NOT EXECUTED
p->avl.right = q;
}
}
else
{
*root = q;
ffc0fc2c: 91 59 00 40 stw r10,64(r25)
ffc0fc30: 4b ff fd 90 b ffc0f9c0 <rtems_bdbuf_remove_from_tree+0x184>
}
/* at this moment q - is a node to delete, p is q's parent */
if (q->avl.right == NULL)
{
r = q->avl.left;
ffc0fc34: 81 5f 00 08 lwz r10,8(r31)
if (r != NULL)
ffc0fc38: 7d 69 5b 78 mr r9,r11
ffc0fc3c: 2f 8a 00 00 cmpwi cr7,r10,0
ffc0fc40: 41 be fd 68 beq- cr7,ffc0f9a8 <rtems_bdbuf_remove_from_tree+0x16c>
{
r->avl.bal = 0;
ffc0fc44: 98 ea 00 11 stb r7,17(r10)
ffc0fc48: 4b ff fd 60 b ffc0f9a8 <rtems_bdbuf_remove_from_tree+0x16c>
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
r->avl.bal = q->avl.bal;
ffc0fc4c: 88 1f 00 11 lbz r0,17(r31)
r->avl.cache = 1;
*buf_prev++ = q = r;
ffc0fc50: 7c ea 3b 78 mr r10,r7
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
ffc0fc54: 81 7f 00 08 lwz r11,8(r31)
r->avl.bal = q->avl.bal;
ffc0fc58: 98 07 00 11 stb r0,17(r7)
r->avl.cache = 1;
ffc0fc5c: 38 00 00 01 li r0,1
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
ffc0fc60: 91 67 00 08 stw r11,8(r7)
r->avl.bal = q->avl.bal;
r->avl.cache = 1;
ffc0fc64: 98 07 00 10 stb r0,16(r7)
*buf_prev++ = q = r;
ffc0fc68: 90 e9 ff fc stw r7,-4(r9)
ffc0fc6c: 4b ff fd 3c b ffc0f9a8 <rtems_bdbuf_remove_from_tree+0x16c>
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
ffc0fc70: 38 00 ff ff li r0,-1 <== NOT EXECUTED
ffc0fc74: 4b ff ff 90 b ffc0fc04 <rtems_bdbuf_remove_from_tree+0x3c8><== NOT EXECUTED
ffc0fc78 <rtems_bdbuf_remove_from_tree_and_lru_list>:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_TREE_RM);
}
static void
rtems_bdbuf_remove_from_tree_and_lru_list (rtems_bdbuf_buffer *bd)
{
ffc0fc78: 94 21 ff f0 stwu r1,-16(r1)
ffc0fc7c: 7c 08 02 a6 mflr r0
ffc0fc80: 90 01 00 14 stw r0,20(r1)
switch (bd->state)
ffc0fc84: 80 03 00 28 lwz r0,40(r3)
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_TREE_RM);
}
static void
rtems_bdbuf_remove_from_tree_and_lru_list (rtems_bdbuf_buffer *bd)
{
ffc0fc88: 93 e1 00 0c stw r31,12(r1)
ffc0fc8c: 7c 7f 1b 78 mr r31,r3
switch (bd->state)
ffc0fc90: 2f 80 00 00 cmpwi cr7,r0,0
ffc0fc94: 41 9e 00 20 beq- cr7,ffc0fcb4 <rtems_bdbuf_remove_from_tree_and_lru_list+0x3c>
ffc0fc98: 2f 80 00 02 cmpwi cr7,r0,2
ffc0fc9c: 41 9e 00 14 beq- cr7,ffc0fcb0 <rtems_bdbuf_remove_from_tree_and_lru_list+0x38><== ALWAYS TAKEN
break;
case RTEMS_BDBUF_STATE_CACHED:
rtems_bdbuf_remove_from_tree (bd);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_10);
ffc0fca0: 3c 80 42 00 lis r4,16896 <== NOT EXECUTED
ffc0fca4: 80 63 00 28 lwz r3,40(r3) <== NOT EXECUTED
ffc0fca8: 60 84 00 08 ori r4,r4,8 <== NOT EXECUTED
ffc0fcac: 4b ff f3 75 bl ffc0f020 <rtems_bdbuf_fatal> <== NOT EXECUTED
switch (bd->state)
{
case RTEMS_BDBUF_STATE_FREE:
break;
case RTEMS_BDBUF_STATE_CACHED:
rtems_bdbuf_remove_from_tree (bd);
ffc0fcb0: 4b ff fb 8d bl ffc0f83c <rtems_bdbuf_remove_from_tree>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
ffc0fcb4: 7f e3 fb 78 mr r3,r31
ffc0fcb8: 4b ff b4 f1 bl ffc0b1a8 <_Chain_Extract>
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_10);
}
rtems_chain_extract (&bd->link);
}
ffc0fcbc: 80 01 00 14 lwz r0,20(r1)
ffc0fcc0: 83 e1 00 0c lwz r31,12(r1)
ffc0fcc4: 38 21 00 10 addi r1,r1,16
ffc0fcc8: 7c 08 03 a6 mtlr r0
ffc0fccc: 4e 80 00 20 blr
ffc0f3e8 <rtems_bdbuf_restore_preemption>:
return prev_mode;
}
static void
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)
{
ffc0f3e8: 94 21 ff f0 stwu r1,-16(r1)
ffc0f3ec: 7c 08 02 a6 mflr r0
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_task_mode (prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode);
ffc0f3f0: 38 80 00 00 li r4,0
return prev_mode;
}
static void
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)
{
ffc0f3f4: 7c 25 0b 78 mr r5,r1
ffc0f3f8: 90 01 00 14 stw r0,20(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_task_mode (prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode);
ffc0f3fc: 60 84 ff ff ori r4,r4,65535
return prev_mode;
}
static void
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)
{
ffc0f400: 94 65 00 08 stwu r3,8(r5)
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_task_mode (prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode);
ffc0f404: 48 00 5b 15 bl ffc14f18 <rtems_task_mode>
if (sc != RTEMS_SUCCESSFUL)
ffc0f408: 2f 83 00 00 cmpwi cr7,r3,0
ffc0f40c: 40 9e 00 14 bne- cr7,ffc0f420 <rtems_bdbuf_restore_preemption+0x38><== NEVER TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_PREEMPT_RST);
}
ffc0f410: 80 01 00 14 lwz r0,20(r1)
ffc0f414: 38 21 00 10 addi r1,r1,16
ffc0f418: 7c 08 03 a6 mtlr r0
ffc0f41c: 4e 80 00 20 blr
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_task_mode (prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_PREEMPT_RST);
ffc0f420: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0f424: 60 63 00 11 ori r3,r3,17 <== NOT EXECUTED
ffc0f428: 4b ff b6 89 bl ffc0aab0 <rtems_fatal_error_occurred> <== NOT EXECUTED
ffc0f038 <rtems_bdbuf_swapout_modified_processing>:
rtems_chain_control* chain,
rtems_chain_control* transfer,
bool sync_active,
bool update_timers,
uint32_t timer_delta)
{
ffc0f038: 94 21 ff c8 stwu r1,-56(r1)
ffc0f03c: 7c 08 02 a6 mflr r0
ffc0f040: 7d 80 00 26 mfcr r12
ffc0f044: 90 01 00 3c stw r0,60(r1)
ffc0f048: 93 c1 00 30 stw r30,48(r1)
ffc0f04c: 7c 9e 23 78 mr r30,r4
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
ffc0f050: 3b de 00 04 addi r30,r30,4
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
ffc0f054: 80 84 00 00 lwz r4,0(r4)
ffc0f058: 93 41 00 20 stw r26,32(r1)
ffc0f05c: 7d 1a 43 78 mr r26,r8
if (!rtems_chain_is_empty (chain))
ffc0f060: 7f 84 f0 00 cmpw cr7,r4,r30
rtems_chain_control* chain,
rtems_chain_control* transfer,
bool sync_active,
bool update_timers,
uint32_t timer_delta)
{
ffc0f064: 93 a1 00 2c stw r29,44(r1)
ffc0f068: 7c bd 2b 78 mr r29,r5
ffc0f06c: 93 e1 00 34 stw r31,52(r1)
ffc0f070: 7c 7f 1b 78 mr r31,r3
ffc0f074: 93 01 00 18 stw r24,24(r1)
ffc0f078: 93 21 00 1c stw r25,28(r1)
ffc0f07c: 93 61 00 24 stw r27,36(r1)
ffc0f080: 93 81 00 28 stw r28,40(r1)
ffc0f084: 91 81 00 14 stw r12,20(r1)
if (!rtems_chain_is_empty (chain))
ffc0f088: 41 9e 00 b0 beq- cr7,ffc0f138 <rtems_bdbuf_swapout_modified_processing+0x100>
node = node->next;
/*
* A sync active with no valid dev means sync all.
*/
if (sync_active && (*dev == BDBUF_INVALID_DEV))
ffc0f08c: 2d 86 00 00 cmpwi cr3,r6,0
sync_all = true;
else
sync_all = false;
ffc0f090: 38 00 00 00 li r0,0
node = node->next;
/*
* A sync active with no valid dev means sync all.
*/
if (sync_active && (*dev == BDBUF_INVALID_DEV))
ffc0f094: 40 8e 01 74 bne- cr3,ffc0f208 <rtems_bdbuf_swapout_modified_processing+0x1d0>
* or someone waits for a buffer written force all the timers to 0.
*
* @note Lots of sync requests will skew this timer. It should be based
* on TOD to be accurate. Does it matter ?
*/
if (sync_all || (sync_active && (*dev == bd->dev))
ffc0f098: 2e 00 00 00 cmpwi cr4,r0,0
|| rtems_bdbuf_has_buffer_waiters ())
bd->hold_timer = 0;
if (bd->hold_timer)
{
if (update_timers)
ffc0f09c: 2d 07 00 00 cmpwi cr2,r7,0
* @note Lots of sync requests will skew this timer. It should be based
* on TOD to be accurate. Does it matter ?
*/
if (sync_all || (sync_active && (*dev == bd->dev))
|| rtems_bdbuf_has_buffer_waiters ())
bd->hold_timer = 0;
ffc0f0a0: 3b 80 00 00 li r28,0
}
static bool
rtems_bdbuf_has_buffer_waiters (void)
{
return bdbuf_cache.buffer_waiters.count;
ffc0f0a4: 3f 60 00 00 lis r27,0
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc0f0a8: 3b 00 00 09 li r24,9
if (sync_active && (*dev == BDBUF_INVALID_DEV))
sync_all = true;
else
sync_all = false;
while (!rtems_chain_is_tail (chain, node))
ffc0f0ac: 7f 84 f0 00 cmpw cr7,r4,r30
ffc0f0b0: 41 9e 00 88 beq- cr7,ffc0f138 <rtems_bdbuf_swapout_modified_processing+0x100>
* or someone waits for a buffer written force all the timers to 0.
*
* @note Lots of sync requests will skew this timer. It should be based
* on TOD to be accurate. Does it matter ?
*/
if (sync_all || (sync_active && (*dev == bd->dev))
ffc0f0b4: 40 92 00 cc bne- cr4,ffc0f180 <rtems_bdbuf_swapout_modified_processing+0x148>
ffc0f0b8: 41 8e 00 14 beq- cr3,ffc0f0cc <rtems_bdbuf_swapout_modified_processing+0x94>
ffc0f0bc: 81 3f 00 00 lwz r9,0(r31)
ffc0f0c0: 80 04 00 18 lwz r0,24(r4)
ffc0f0c4: 7f 89 00 00 cmpw cr7,r9,r0
ffc0f0c8: 41 9e 00 a8 beq- cr7,ffc0f170 <rtems_bdbuf_swapout_modified_processing+0x138>
}
static bool
rtems_bdbuf_has_buffer_waiters (void)
{
return bdbuf_cache.buffer_waiters.count;
ffc0f0cc: 39 3b 2a 08 addi r9,r27,10760
ffc0f0d0: 80 09 00 78 lwz r0,120(r9)
*
* @note Lots of sync requests will skew this timer. It should be based
* on TOD to be accurate. Does it matter ?
*/
if (sync_all || (sync_active && (*dev == bd->dev))
|| rtems_bdbuf_has_buffer_waiters ())
ffc0f0d4: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f0d8: 40 9e 00 a8 bne- cr7,ffc0f180 <rtems_bdbuf_swapout_modified_processing+0x148>
bd->hold_timer = 0;
if (bd->hold_timer)
ffc0f0dc: 80 04 00 34 lwz r0,52(r4)
ffc0f0e0: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f0e4: 41 9e 00 2c beq- cr7,ffc0f110 <rtems_bdbuf_swapout_modified_processing+0xd8>
{
if (update_timers)
ffc0f0e8: 41 8a 00 1c beq- cr2,ffc0f104 <rtems_bdbuf_swapout_modified_processing+0xcc>
{
if (bd->hold_timer > timer_delta)
ffc0f0ec: 80 04 00 34 lwz r0,52(r4)
ffc0f0f0: 7f 80 d0 40 cmplw cr7,r0,r26
ffc0f0f4: 40 9d 01 0c ble- cr7,ffc0f200 <rtems_bdbuf_swapout_modified_processing+0x1c8>
bd->hold_timer -= timer_delta;
ffc0f0f8: 80 04 00 34 lwz r0,52(r4)
ffc0f0fc: 7c 1a 00 50 subf r0,r26,r0
ffc0f100: 90 04 00 34 stw r0,52(r4)
else
bd->hold_timer = 0;
}
if (bd->hold_timer)
ffc0f104: 80 04 00 34 lwz r0,52(r4)
ffc0f108: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f10c: 40 9e 00 20 bne- cr7,ffc0f12c <rtems_bdbuf_swapout_modified_processing+0xf4>
/*
* This assumes we can set dev_t to BDBUF_INVALID_DEV which is just an
* assumption. Cannot use the transfer list being empty the sync dev
* calls sets the dev to use.
*/
if (*dev == BDBUF_INVALID_DEV)
ffc0f110: 80 1f 00 00 lwz r0,0(r31)
ffc0f114: 81 7f 00 04 lwz r11,4(r31)
ffc0f118: 2f 80 ff ff cmpwi cr7,r0,-1
ffc0f11c: 41 9e 00 c8 beq- cr7,ffc0f1e4 <rtems_bdbuf_swapout_modified_processing+0x1ac>
*dev = bd->dev;
if (bd->dev == *dev)
ffc0f120: 81 24 00 18 lwz r9,24(r4)
ffc0f124: 7f 89 00 00 cmpw cr7,r9,r0
ffc0f128: 41 9e 00 60 beq- cr7,ffc0f188 <rtems_bdbuf_swapout_modified_processing+0x150><== ALWAYS TAKEN
node = next_node;
}
else
{
node = node->next;
ffc0f12c: 80 84 00 00 lwz r4,0(r4)
if (sync_active && (*dev == BDBUF_INVALID_DEV))
sync_all = true;
else
sync_all = false;
while (!rtems_chain_is_tail (chain, node))
ffc0f130: 7f 84 f0 00 cmpw cr7,r4,r30
ffc0f134: 40 9e ff 80 bne+ cr7,ffc0f0b4 <rtems_bdbuf_swapout_modified_processing+0x7c>
{
node = node->next;
}
}
}
}
ffc0f138: 80 01 00 3c lwz r0,60(r1)
ffc0f13c: 81 81 00 14 lwz r12,20(r1)
ffc0f140: 7c 08 03 a6 mtlr r0
ffc0f144: 83 01 00 18 lwz r24,24(r1)
ffc0f148: 83 21 00 1c lwz r25,28(r1)
ffc0f14c: 7d 83 81 20 mtcrf 56,r12
ffc0f150: 83 41 00 20 lwz r26,32(r1)
ffc0f154: 83 61 00 24 lwz r27,36(r1)
ffc0f158: 83 81 00 28 lwz r28,40(r1)
ffc0f15c: 83 a1 00 2c lwz r29,44(r1)
ffc0f160: 83 c1 00 30 lwz r30,48(r1)
ffc0f164: 83 e1 00 34 lwz r31,52(r1)
ffc0f168: 38 21 00 38 addi r1,r1,56
ffc0f16c: 4e 80 00 20 blr
* or someone waits for a buffer written force all the timers to 0.
*
* @note Lots of sync requests will skew this timer. It should be based
* on TOD to be accurate. Does it matter ?
*/
if (sync_all || (sync_active && (*dev == bd->dev))
ffc0f170: 81 3f 00 04 lwz r9,4(r31)
ffc0f174: 80 04 00 1c lwz r0,28(r4)
ffc0f178: 7f 89 00 00 cmpw cr7,r9,r0
ffc0f17c: 40 9e ff 50 bne+ cr7,ffc0f0cc <rtems_bdbuf_swapout_modified_processing+0x94><== NEVER TAKEN
|| rtems_bdbuf_has_buffer_waiters ())
bd->hold_timer = 0;
ffc0f180: 93 84 00 34 stw r28,52(r4)
ffc0f184: 4b ff ff 58 b ffc0f0dc <rtems_bdbuf_swapout_modified_processing+0xa4>
* calls sets the dev to use.
*/
if (*dev == BDBUF_INVALID_DEV)
*dev = bd->dev;
if (bd->dev == *dev)
ffc0f188: 80 04 00 1c lwz r0,28(r4)
ffc0f18c: 7f 80 58 00 cmpw cr7,r0,r11
ffc0f190: 40 9e ff 9c bne+ cr7,ffc0f12c <rtems_bdbuf_swapout_modified_processing+0xf4><== NEVER TAKEN
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc0f194: 93 04 00 28 stw r24,40(r4)
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
ffc0f198: 7c 83 23 78 mr r3,r4
if (*dev == BDBUF_INVALID_DEV)
*dev = bd->dev;
if (bd->dev == *dev)
{
rtems_chain_node* next_node = node->next;
ffc0f19c: 83 24 00 00 lwz r25,0(r4)
ffc0f1a0: 90 81 00 08 stw r4,8(r1)
ffc0f1a4: 4b ff c0 05 bl ffc0b1a8 <_Chain_Extract>
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
rtems_chain_extract (node);
tnode = tnode->previous;
ffc0f1a8: 80 7d 00 08 lwz r3,8(r29)
while (node && !rtems_chain_is_head (transfer, tnode))
ffc0f1ac: 80 81 00 08 lwz r4,8(r1)
ffc0f1b0: 7f 9d 18 00 cmpw cr7,r29,r3
ffc0f1b4: 41 9e 00 20 beq- cr7,ffc0f1d4 <rtems_bdbuf_swapout_modified_processing+0x19c>
ffc0f1b8: 81 24 00 20 lwz r9,32(r4)
{
rtems_bdbuf_buffer* tbd = (rtems_bdbuf_buffer*) tnode;
if (bd->block > tbd->block)
ffc0f1bc: 80 03 00 20 lwz r0,32(r3)
ffc0f1c0: 7f 89 00 40 cmplw cr7,r9,r0
ffc0f1c4: 41 9d 00 14 bgt- cr7,ffc0f1d8 <rtems_bdbuf_swapout_modified_processing+0x1a0>
{
rtems_chain_insert (tnode, node);
node = NULL;
}
else
tnode = tnode->previous;
ffc0f1c8: 80 63 00 04 lwz r3,4(r3)
rtems_chain_extract (node);
tnode = tnode->previous;
while (node && !rtems_chain_is_head (transfer, tnode))
ffc0f1cc: 7f 9d 18 00 cmpw cr7,r29,r3
ffc0f1d0: 40 9e ff ec bne+ cr7,ffc0f1bc <rtems_bdbuf_swapout_modified_processing+0x184>
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
ffc0f1d4: 7f a3 eb 78 mr r3,r29
ffc0f1d8: 48 00 63 6d bl ffc15544 <_Chain_Insert>
}
if (node)
rtems_chain_prepend (transfer, node);
node = next_node;
ffc0f1dc: 7f 24 cb 78 mr r4,r25
ffc0f1e0: 4b ff fe cc b ffc0f0ac <rtems_bdbuf_swapout_modified_processing+0x74>
/*
* This assumes we can set dev_t to BDBUF_INVALID_DEV which is just an
* assumption. Cannot use the transfer list being empty the sync dev
* calls sets the dev to use.
*/
if (*dev == BDBUF_INVALID_DEV)
ffc0f1e4: 2f 8b ff ff cmpwi cr7,r11,-1
ffc0f1e8: 40 9e ff 38 bne+ cr7,ffc0f120 <rtems_bdbuf_swapout_modified_processing+0xe8><== NEVER TAKEN
*dev = bd->dev;
ffc0f1ec: 80 04 00 18 lwz r0,24(r4)
ffc0f1f0: 81 64 00 1c lwz r11,28(r4)
ffc0f1f4: 90 1f 00 00 stw r0,0(r31)
ffc0f1f8: 91 7f 00 04 stw r11,4(r31)
ffc0f1fc: 4b ff ff 24 b ffc0f120 <rtems_bdbuf_swapout_modified_processing+0xe8>
if (update_timers)
{
if (bd->hold_timer > timer_delta)
bd->hold_timer -= timer_delta;
else
bd->hold_timer = 0;
ffc0f200: 93 84 00 34 stw r28,52(r4)
ffc0f204: 4b ff ff 00 b ffc0f104 <rtems_bdbuf_swapout_modified_processing+0xcc>
* @param update_timers If true update the timers.
* @param timer_delta It update_timers is true update the timers by this
* amount.
*/
static void
rtems_bdbuf_swapout_modified_processing (dev_t* dev,
ffc0f208: 80 03 00 04 lwz r0,4(r3)
ffc0f20c: 81 23 00 00 lwz r9,0(r3)
ffc0f210: 7d 29 00 38 and r9,r9,r0
ffc0f214: 38 09 00 01 addi r0,r9,1
ffc0f218: 7c 00 00 34 cntlzw r0,r0
ffc0f21c: 54 00 d9 7e rlwinm r0,r0,27,5,31
ffc0f220: 4b ff fe 78 b ffc0f098 <rtems_bdbuf_swapout_modified_processing+0x60>
ffc103d8 <rtems_bdbuf_swapout_task>:
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
{
ffc103d8: 94 21 ff 88 stwu r1,-120(r1)
ffc103dc: 7c 08 02 a6 mflr r0
ffc103e0: 93 41 00 60 stw r26,96(r1)
rtems_bdbuf_swapout_transfer transfer;
uint32_t period_in_ticks;
const uint32_t period_in_msecs = bdbuf_config.swapout_period;;
ffc103e4: 3f 40 ff c2 lis r26,-62
ffc103e8: 3b 5a e1 74 addi r26,r26,-7820
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
{
ffc103ec: 93 21 00 5c stw r25,92(r1)
rtems_bdbuf_swapout_transfer transfer;
uint32_t period_in_ticks;
const uint32_t period_in_msecs = bdbuf_config.swapout_period;;
ffc103f0: 83 3a 00 0c lwz r25,12(r26)
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
{
ffc103f4: 90 01 00 7c stw r0,124(r1)
ffc103f8: 92 21 00 3c stw r17,60(r1)
ffc103fc: 92 41 00 40 stw r18,64(r1)
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
ffc10400: 1e 59 03 e8 mulli r18,r25,1000
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
{
ffc10404: 92 e1 00 54 stw r23,84(r1)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc10408: 3a e1 00 10 addi r23,r1,16
ffc1040c: 92 61 00 44 stw r19,68(r1)
ffc10410: 92 81 00 48 stw r20,72(r1)
ffc10414: 92 a1 00 4c stw r21,76(r1)
ffc10418: 92 c1 00 50 stw r22,80(r1)
ffc1041c: 93 01 00 58 stw r24,88(r1)
ffc10420: 93 61 00 64 stw r27,100(r1)
ffc10424: 93 81 00 68 stw r28,104(r1)
ffc10428: 93 a1 00 6c stw r29,108(r1)
ffc1042c: 93 c1 00 70 stw r30,112(r1)
ffc10430: 93 e1 00 74 stw r31,116(r1)
rtems_bdbuf_swapout_transfer transfer;
uint32_t period_in_ticks;
const uint32_t period_in_msecs = bdbuf_config.swapout_period;;
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
ffc10434: 4b ff f0 f9 bl ffc0f52c <rtems_bdbuf_swapout_writereq_alloc>
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
ffc10438: 3d 20 00 00 lis r9,0
ffc1043c: 80 09 20 10 lwz r0,8208(r9)
ffc10440: 39 61 00 14 addi r11,r1,20
head->previous = NULL;
ffc10444: 39 20 00 00 li r9,0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc10448: 91 61 00 10 stw r11,16(r1)
const uint32_t period_in_msecs = bdbuf_config.swapout_period;;
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&transfer.bds);
transfer.dev = BDBUF_INVALID_DEV;
ffc1044c: 39 40 ff ff li r10,-1
ffc10450: 39 60 ff ff li r11,-1
rtems_bdbuf_swapout_transfer transfer;
uint32_t period_in_ticks;
const uint32_t period_in_msecs = bdbuf_config.swapout_period;;
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
ffc10454: 90 61 00 2c stw r3,44(r1)
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
ffc10458: 7e 52 03 96 divwu r18,r18,r0
head->previous = NULL;
ffc1045c: 91 21 00 14 stw r9,20(r1)
tail->previous = head;
ffc10460: 92 e1 00 18 stw r23,24(r1)
const uint32_t period_in_msecs = bdbuf_config.swapout_period;;
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&transfer.bds);
transfer.dev = BDBUF_INVALID_DEV;
ffc10464: 91 41 00 20 stw r10,32(r1)
ffc10468: 91 61 00 24 stw r11,36(r1)
transfer.syncing = false;
ffc1046c: 99 21 00 28 stb r9,40(r1)
rtems_bdbuf_swapout_workers_open (void)
{
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
ffc10470: 4b ff eb 29 bl ffc0ef98 <rtems_bdbuf_lock_cache>
for (w = 0; w < bdbuf_config.swapout_workers; w++)
ffc10474: 82 3a 00 14 lwz r17,20(r26)
ffc10478: 2f 91 00 00 cmpwi cr7,r17,0
ffc1047c: 41 9e 03 28 beq- cr7,ffc107a4 <rtems_bdbuf_swapout_task+0x3cc><== ALWAYS TAKEN
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
if (!worker)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
ffc10480: 3f 00 00 00 lis r24,0 <== NOT EXECUTED
ffc10484: 3b 18 2a 08 addi r24,r24,10760 <== NOT EXECUTED
RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_CREATE);
sc = rtems_task_start (worker->id,
ffc10488: 3e c0 ff c1 lis r22,-63 <== NOT EXECUTED
* @param arg A pointer to the global cache data. Use the global variable and
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
ffc1048c: 3a 31 00 61 addi r17,r17,97 <== NOT EXECUTED
ffc10490: 3b 60 00 61 li r27,97 <== NOT EXECUTED
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
if (!worker)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
ffc10494: 3a 78 00 08 addi r19,r24,8 <== NOT EXECUTED
worker->enabled = true;
ffc10498: 3a 80 00 01 li r20,1 <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
ffc1049c: 3a a0 00 00 li r21,0 <== NOT EXECUTED
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
ffc104a0: 3b c0 ff ff li r30,-1 <== NOT EXECUTED
ffc104a4: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_CREATE);
sc = rtems_task_start (worker->id,
ffc104a8: 3a d6 07 d4 addi r22,r22,2004 <== NOT EXECUTED
for (w = 0; w < bdbuf_config.swapout_workers; w++)
{
rtems_bdbuf_swapout_worker* worker;
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
ffc104ac: 38 60 00 38 li r3,56 <== NOT EXECUTED
ffc104b0: 4b ff 5c 89 bl ffc06138 <malloc> <== NOT EXECUTED
if (!worker)
ffc104b4: 7c 7d 1b 79 mr. r29,r3 <== NOT EXECUTED
ffc104b8: 41 82 03 04 beq- ffc107bc <rtems_bdbuf_swapout_task+0x3e4><== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
ffc104bc: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc104c0: 7e 63 9b 78 mr r3,r19 <== NOT EXECUTED
ffc104c4: 4b ff ac b5 bl ffc0b178 <_Chain_Append> <== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
ffc104c8: 9a 9d 00 0c stb r20,12(r29) <== NOT EXECUTED
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
if (!worker)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
ffc104cc: 7f 1c c3 78 mr r28,r24 <== NOT EXECUTED
worker->enabled = true;
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
ffc104d0: 4b ff f0 5d bl ffc0f52c <rtems_bdbuf_swapout_writereq_alloc><== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
sc = rtems_task_create (rtems_build_name('B', 'D', 'o', 'a' + w),
(bdbuf_config.swapout_priority ?
ffc104d4: 80 9a 00 08 lwz r4,8(r26) <== NOT EXECUTED
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 );
ffc104d8: 38 1d 00 10 addi r0,r29,16 <== NOT EXECUTED
if (!worker)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
ffc104dc: 90 7d 00 2c stw r3,44(r29) <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
sc = rtems_task_create (rtems_build_name('B', 'D', 'o', 'a' + w),
ffc104e0: 2f 84 00 00 cmpwi cr7,r4,0 <== NOT EXECUTED
ffc104e4: 39 3d 00 14 addi r9,r29,20 <== NOT EXECUTED
head->next = tail;
head->previous = NULL;
ffc104e8: 92 bd 00 14 stw r21,20(r29) <== NOT EXECUTED
ffc104ec: 67 6b 42 44 oris r11,r27,16964 <== NOT EXECUTED
ffc104f0: 61 63 6f 00 ori r3,r11,28416 <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc104f4: 91 3d 00 10 stw r9,16(r29) <== NOT EXECUTED
head->previous = NULL;
tail->previous = head;
ffc104f8: 90 1d 00 18 stw r0,24(r29) <== NOT EXECUTED
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
ffc104fc: 93 dd 00 20 stw r30,32(r29) <== NOT EXECUTED
ffc10500: 93 fd 00 24 stw r31,36(r29) <== NOT EXECUTED
sc = rtems_task_create (rtems_build_name('B', 'D', 'o', 'a' + w),
ffc10504: 40 9e 00 08 bne- cr7,ffc1050c <rtems_bdbuf_swapout_task+0x134><== NOT EXECUTED
ffc10508: 38 80 00 0f li r4,15 <== NOT EXECUTED
ffc1050c: 38 a0 20 00 li r5,8192 <== NOT EXECUTED
ffc10510: 38 c0 04 00 li r6,1024 <== NOT EXECUTED
ffc10514: 38 e0 00 00 li r7,0 <== NOT EXECUTED
ffc10518: 39 1d 00 08 addi r8,r29,8 <== NOT EXECUTED
ffc1051c: 4b ff 9e e5 bl ffc0a400 <rtems_task_create> <== NOT EXECUTED
RTEMS_BDBUF_SWAPOUT_TASK_PRIORITY_DEFAULT),
SWAPOUT_TASK_STACK_SIZE,
RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
ffc10520: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc10524: 40 9e 02 8c bne- cr7,ffc107b0 <rtems_bdbuf_swapout_task+0x3d8><== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_CREATE);
sc = rtems_task_start (worker->id,
ffc10528: 80 7d 00 08 lwz r3,8(r29) <== NOT EXECUTED
ffc1052c: 7e c4 b3 78 mr r4,r22 <== NOT EXECUTED
ffc10530: 7f a5 eb 78 mr r5,r29 <== NOT EXECUTED
ffc10534: 4b ff a2 1d bl ffc0a750 <rtems_task_start> <== NOT EXECUTED
rtems_bdbuf_swapout_worker_task,
(rtems_task_argument) worker);
if (sc != RTEMS_SUCCESSFUL)
ffc10538: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1053c: 40 9e 02 8c bne- cr7,ffc107c8 <rtems_bdbuf_swapout_task+0x3f0><== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_START);
ffc10540: 3b 7b 00 01 addi r27,r27,1 <== NOT EXECUTED
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
for (w = 0; w < bdbuf_config.swapout_workers; w++)
ffc10544: 7f 9b 88 00 cmpw cr7,r27,r17 <== NOT EXECUTED
ffc10548: 40 9e ff 64 bne+ cr7,ffc104ac <rtems_bdbuf_swapout_task+0xd4><== NOT EXECUTED
ffc1054c: 3e c0 00 00 lis r22,0
(rtems_task_argument) worker);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_START);
}
rtems_bdbuf_unlock_cache ();
ffc10550: 4b ff ec d5 bl ffc0f224 <rtems_bdbuf_unlock_cache>
ffc10554: 3a d6 2a 64 addi r22,r22,10852
ffc10558: 3a 96 ff f4 addi r20,r22,-12
* until after we have it running so we do not know to tell it to release the
* lock. The simplest solution is to get the main swap out task perform all
* sync operations.
*/
if (bdbuf_cache.sync_active)
worker = NULL;
ffc1055c: 3a a0 00 00 li r21,0
else
{
worker = (rtems_bdbuf_swapout_worker*)
rtems_chain_get (&bdbuf_cache.swapout_workers);
ffc10560: 3a 7c 00 08 addi r19,r28,8
if (worker)
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dev = BDBUF_INVALID_DEV;
ffc10564: 3b c0 ff ff li r30,-1
ffc10568: 3b e0 ff ff li r31,-1
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
ffc1056c: 88 1c 00 04 lbz r0,4(r28)
ffc10570: 2f 80 00 00 cmpwi cr7,r0,0
ffc10574: 41 9e 01 90 beq- cr7,ffc10704 <rtems_bdbuf_swapout_task+0x32c><== NEVER TAKEN
rtems_bdbuf_swapout_transfer* transfer)
{
rtems_bdbuf_swapout_worker* worker;
bool transfered_buffers = false;
rtems_bdbuf_lock_cache ();
ffc10578: 4b ff ea 21 bl ffc0ef98 <rtems_bdbuf_lock_cache>
* here. We do not know the worker is the last in a sequence of sync writes
* until after we have it running so we do not know to tell it to release the
* lock. The simplest solution is to get the main swap out task perform all
* sync operations.
*/
if (bdbuf_cache.sync_active)
ffc1057c: 88 1c 00 30 lbz r0,48(r28)
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
ffc10580: 3b 00 00 01 li r24,1
* here. We do not know the worker is the last in a sequence of sync writes
* until after we have it running so we do not know to tell it to release the
* lock. The simplest solution is to get the main swap out task perform all
* sync operations.
*/
if (bdbuf_cache.sync_active)
ffc10584: 2f 80 00 00 cmpwi cr7,r0,0
worker = NULL;
ffc10588: 3b 60 00 00 li r27,0
/*
* Extact all the buffers we find for a specific device. The device is
* the first one we find on a modified list. Process the sync queue of
* buffers first.
*/
if (rtems_bdbuf_swapout_processing (timer_delta,
ffc1058c: 7e fd bb 78 mr r29,r23
* here. We do not know the worker is the last in a sequence of sync writes
* until after we have it running so we do not know to tell it to release the
* lock. The simplest solution is to get the main swap out task perform all
* sync operations.
*/
if (bdbuf_cache.sync_active)
ffc10590: 41 9e 00 dc beq- cr7,ffc1066c <rtems_bdbuf_swapout_task+0x294>
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dev = BDBUF_INVALID_DEV;
transfer->syncing = bdbuf_cache.sync_active;
ffc10594: 88 1c 00 30 lbz r0,48(r28)
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 );
ffc10598: 3b 5d 00 04 addi r26,r29,4
/*
* When the sync is for a device limit the sync to that device. If the sync
* is for a buffer handle process the devices in the order on the sync
* list. This means the dev is BDBUF_INVALID_DEV.
*/
if (bdbuf_cache.sync_active)
ffc1059c: 89 3c 00 30 lbz r9,48(r28)
head->next = tail;
ffc105a0: 93 5d 00 00 stw r26,0(r29)
ffc105a4: 2f 89 00 00 cmpwi cr7,r9,0
head->previous = NULL;
ffc105a8: 92 bd 00 04 stw r21,4(r29)
tail->previous = head;
ffc105ac: 93 bd 00 08 stw r29,8(r29)
if (worker)
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dev = BDBUF_INVALID_DEV;
ffc105b0: 93 dd 00 10 stw r30,16(r29)
ffc105b4: 93 fd 00 14 stw r31,20(r29)
transfer->syncing = bdbuf_cache.sync_active;
ffc105b8: 98 1d 00 18 stb r0,24(r29)
/*
* When the sync is for a device limit the sync to that device. If the sync
* is for a buffer handle process the devices in the order on the sync
* list. This means the dev is BDBUF_INVALID_DEV.
*/
if (bdbuf_cache.sync_active)
ffc105bc: 41 9e 00 14 beq- cr7,ffc105d0 <rtems_bdbuf_swapout_task+0x1f8>
transfer->dev = bdbuf_cache.sync_device;
ffc105c0: 81 5c 00 38 lwz r10,56(r28)
ffc105c4: 81 7c 00 3c lwz r11,60(r28)
ffc105c8: 91 5d 00 10 stw r10,16(r29)
ffc105cc: 91 7d 00 14 stw r11,20(r29)
/*
* If we have any buffers in the sync queue move them to the modified
* list. The first sync buffer will select the device we use.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dev,
ffc105d0: 3a 3d 00 10 addi r17,r29,16
ffc105d4: 38 c0 00 01 li r6,1
ffc105d8: 38 e0 00 00 li r7,0
ffc105dc: 7f 28 cb 78 mr r8,r25
ffc105e0: 7e 23 8b 78 mr r3,r17
ffc105e4: 7e c4 b3 78 mr r4,r22
ffc105e8: 7f a5 eb 78 mr r5,r29
ffc105ec: 4b ff ea 4d bl ffc0f038 <rtems_bdbuf_swapout_modified_processing>
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dev,
ffc105f0: 88 dc 00 30 lbz r6,48(r28)
ffc105f4: 7e 23 8b 78 mr r3,r17
ffc105f8: 7e 84 a3 78 mr r4,r20
ffc105fc: 7f a5 eb 78 mr r5,r29
ffc10600: 7f 07 c3 78 mr r7,r24
ffc10604: 7f 28 cb 78 mr r8,r25
ffc10608: 4b ff ea 31 bl ffc0f038 <rtems_bdbuf_swapout_modified_processing>
/*
* We have all the buffers that have been modified for this device so the
* cache can be unlocked because the state of each buffer has been set to
* TRANSFER.
*/
rtems_bdbuf_unlock_cache ();
ffc1060c: 4b ff ec 19 bl ffc0f224 <rtems_bdbuf_unlock_cache>
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
ffc10610: 80 1d 00 00 lwz r0,0(r29)
ffc10614: 7f 80 d0 00 cmpw cr7,r0,r26
ffc10618: 41 9e 00 d4 beq- cr7,ffc106ec <rtems_bdbuf_swapout_task+0x314>
{
if (worker)
ffc1061c: 2f 9b 00 00 cmpwi cr7,r27,0
ffc10620: 41 9e 00 d4 beq- cr7,ffc106f4 <rtems_bdbuf_swapout_task+0x31c><== ALWAYS TAKEN
{
rtems_status_code sc = rtems_event_send (worker->id,
ffc10624: 80 7b 00 08 lwz r3,8(r27) <== NOT EXECUTED
ffc10628: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc1062c: 4b ff 96 15 bl ffc09c40 <rtems_event_send> <== NOT EXECUTED
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
ffc10630: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc10634: 40 9e 01 64 bne- cr7,ffc10798 <rtems_bdbuf_swapout_task+0x3c0><== NOT EXECUTED
else
{
rtems_bdbuf_swapout_write (transfer);
}
transfered_buffers = true;
ffc10638: 3b a0 00 01 li r29,1 <== NOT EXECUTED
}
if (bdbuf_cache.sync_active && !transfered_buffers)
ffc1063c: 88 1c 00 30 lbz r0,48(r28)
ffc10640: 2f 80 00 00 cmpwi cr7,r0,0
ffc10644: 41 9e 00 98 beq- cr7,ffc106dc <rtems_bdbuf_swapout_task+0x304>
ffc10648: 2f 9d 00 00 cmpwi cr7,r29,0
ffc1064c: 41 9e 00 38 beq- cr7,ffc10684 <rtems_bdbuf_swapout_task+0x2ac>
/*
* Extact all the buffers we find for a specific device. The device is
* the first one we find on a modified list. Process the sync queue of
* buffers first.
*/
if (rtems_bdbuf_swapout_processing (timer_delta,
ffc10650: 3b 00 00 00 li r24,0
rtems_bdbuf_swapout_transfer* transfer)
{
rtems_bdbuf_swapout_worker* worker;
bool transfered_buffers = false;
rtems_bdbuf_lock_cache ();
ffc10654: 4b ff e9 45 bl ffc0ef98 <rtems_bdbuf_lock_cache>
* here. We do not know the worker is the last in a sequence of sync writes
* until after we have it running so we do not know to tell it to release the
* lock. The simplest solution is to get the main swap out task perform all
* sync operations.
*/
if (bdbuf_cache.sync_active)
ffc10658: 88 1c 00 30 lbz r0,48(r28)
worker = NULL;
ffc1065c: 3b 60 00 00 li r27,0
* here. We do not know the worker is the last in a sequence of sync writes
* until after we have it running so we do not know to tell it to release the
* lock. The simplest solution is to get the main swap out task perform all
* sync operations.
*/
if (bdbuf_cache.sync_active)
ffc10660: 2f 80 00 00 cmpwi cr7,r0,0
/*
* Extact all the buffers we find for a specific device. The device is
* the first one we find on a modified list. Process the sync queue of
* buffers first.
*/
if (rtems_bdbuf_swapout_processing (timer_delta,
ffc10664: 7e fd bb 78 mr r29,r23
* here. We do not know the worker is the last in a sequence of sync writes
* until after we have it running so we do not know to tell it to release the
* lock. The simplest solution is to get the main swap out task perform all
* sync operations.
*/
if (bdbuf_cache.sync_active)
ffc10668: 40 9e ff 2c bne+ cr7,ffc10594 <rtems_bdbuf_swapout_task+0x1bc>
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
ffc1066c: 7e 63 9b 78 mr r3,r19
ffc10670: 4b ff ab 61 bl ffc0b1d0 <_Chain_Get>
worker = NULL;
else
{
worker = (rtems_bdbuf_swapout_worker*)
rtems_chain_get (&bdbuf_cache.swapout_workers);
if (worker)
ffc10674: 7c 7b 1b 79 mr. r27,r3
ffc10678: 41 a2 ff 1c beq- ffc10594 <rtems_bdbuf_swapout_task+0x1bc><== ALWAYS TAKEN
transfer = &worker->transfer;
ffc1067c: 3b bb 00 10 addi r29,r27,16 <== NOT EXECUTED
ffc10680: 4b ff ff 14 b ffc10594 <rtems_bdbuf_swapout_task+0x1bc><== NOT EXECUTED
}
if (bdbuf_cache.sync_active && !transfered_buffers)
{
rtems_id sync_requester;
rtems_bdbuf_lock_cache ();
ffc10684: 4b ff e9 15 bl ffc0ef98 <rtems_bdbuf_lock_cache>
sync_requester = bdbuf_cache.sync_requester;
ffc10688: 83 7c 00 34 lwz r27,52(r28)
bdbuf_cache.sync_active = false;
ffc1068c: 9b bc 00 30 stb r29,48(r28)
bdbuf_cache.sync_requester = 0;
ffc10690: 93 bc 00 34 stw r29,52(r28)
rtems_bdbuf_unlock_cache ();
ffc10694: 4b ff eb 91 bl ffc0f224 <rtems_bdbuf_unlock_cache>
if (sync_requester)
ffc10698: 2f 9b 00 00 cmpwi cr7,r27,0
ffc1069c: 41 be 00 10 beq+ cr7,ffc106ac <rtems_bdbuf_swapout_task+0x2d4><== NEVER TAKEN
rtems_event_send (sync_requester, RTEMS_BDBUF_TRANSFER_SYNC);
ffc106a0: 7f 63 db 78 mr r3,r27
ffc106a4: 38 80 00 02 li r4,2
ffc106a8: 4b ff 95 99 bl ffc09c40 <rtems_event_send>
*/
update_timers = false;
}
while (transfered_buffers);
sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,
ffc106ac: 38 60 00 04 li r3,4
ffc106b0: 38 80 00 00 li r4,0
ffc106b4: 7e 45 93 78 mr r5,r18
ffc106b8: 38 c1 00 08 addi r6,r1,8
ffc106bc: 4b ff 93 7d bl ffc09a38 <rtems_event_receive>
RTEMS_EVENT_ALL | RTEMS_WAIT,
period_in_ticks,
&out);
if ((sc != RTEMS_SUCCESSFUL) && (sc != RTEMS_TIMEOUT))
ffc106c0: 2c 03 00 00 cmpwi r3,0
ffc106c4: 41 a2 fe a8 beq- ffc1056c <rtems_bdbuf_swapout_task+0x194>
ffc106c8: 2f 83 00 06 cmpwi cr7,r3,6
ffc106cc: 41 9e fe a0 beq+ cr7,ffc1056c <rtems_bdbuf_swapout_task+0x194><== ALWAYS TAKEN
rtems_fatal_error_occurred (BLKDEV_FATAL_BDBUF_SWAPOUT_RE);
ffc106d0: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc106d4: 60 63 00 18 ori r3,r3,24 <== NOT EXECUTED
ffc106d8: 4b ff a3 d9 bl ffc0aab0 <rtems_fatal_error_occurred> <== NOT EXECUTED
/*
* Extact all the buffers we find for a specific device. The device is
* the first one we find on a modified list. Process the sync queue of
* buffers first.
*/
if (rtems_bdbuf_swapout_processing (timer_delta,
ffc106dc: 2f 9d 00 00 cmpwi cr7,r29,0
ffc106e0: 41 9e ff cc beq+ cr7,ffc106ac <rtems_bdbuf_swapout_task+0x2d4>
ffc106e4: 3b 00 00 00 li r24,0
ffc106e8: 4b ff ff 6c b ffc10654 <rtems_bdbuf_swapout_task+0x27c>
rtems_bdbuf_swapout_processing (unsigned long timer_delta,
bool update_timers,
rtems_bdbuf_swapout_transfer* transfer)
{
rtems_bdbuf_swapout_worker* worker;
bool transfered_buffers = false;
ffc106ec: 3b a0 00 00 li r29,0
ffc106f0: 4b ff ff 4c b ffc1063c <rtems_bdbuf_swapout_task+0x264>
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WAKE);
}
else
{
rtems_bdbuf_swapout_write (transfer);
ffc106f4: 7f a3 eb 78 mr r3,r29
ffc106f8: 4b ff fa c9 bl ffc101c0 <rtems_bdbuf_swapout_write>
}
transfered_buffers = true;
ffc106fc: 3b a0 00 01 li r29,1
ffc10700: 4b ff ff 3c b ffc1063c <rtems_bdbuf_swapout_task+0x264>
static void
rtems_bdbuf_swapout_workers_close (void)
{
rtems_chain_node* node;
rtems_bdbuf_lock_cache ();
ffc10704: 4b ff e8 95 bl ffc0ef98 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc10708: 83 dc 00 08 lwz r30,8(r28) <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return &the_chain->Tail.Node;
ffc1070c: 3b 9c 00 0c addi r28,r28,12 <== NOT EXECUTED
node = rtems_chain_first (&bdbuf_cache.swapout_workers);
while (!rtems_chain_is_tail (&bdbuf_cache.swapout_workers, node))
ffc10710: 7f 9e e0 00 cmpw cr7,r30,r28 <== NOT EXECUTED
ffc10714: 41 9e 00 24 beq- cr7,ffc10738 <rtems_bdbuf_swapout_task+0x360><== NOT EXECUTED
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) node;
worker->enabled = false;
ffc10718: 3b a0 00 00 li r29,0 <== NOT EXECUTED
ffc1071c: 9b be 00 0c stb r29,12(r30) <== NOT EXECUTED
rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);
ffc10720: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc10724: 80 7e 00 08 lwz r3,8(r30) <== NOT EXECUTED
ffc10728: 4b ff 95 19 bl ffc09c40 <rtems_event_send> <== NOT EXECUTED
rtems_bdbuf_purge_major (rtems_device_major_number major)
{
dev_t dev = rtems_filesystem_make_dev_t (major, 0);
rtems_bdbuf_purge (rtems_bdbuf_purge_compare_major, dev);
}
ffc1072c: 83 de 00 00 lwz r30,0(r30) <== NOT EXECUTED
rtems_chain_node* node;
rtems_bdbuf_lock_cache ();
node = rtems_chain_first (&bdbuf_cache.swapout_workers);
while (!rtems_chain_is_tail (&bdbuf_cache.swapout_workers, node))
ffc10730: 7f 9e e0 00 cmpw cr7,r30,r28 <== NOT EXECUTED
ffc10734: 40 9e ff e8 bne+ cr7,ffc1071c <rtems_bdbuf_swapout_task+0x344><== NOT EXECUTED
worker->enabled = false;
rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);
node = rtems_chain_next (node);
}
rtems_bdbuf_unlock_cache ();
ffc10738: 4b ff ea ed bl ffc0f224 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
rtems_fatal_error_occurred (BLKDEV_FATAL_BDBUF_SWAPOUT_RE);
}
rtems_bdbuf_swapout_workers_close ();
free (transfer.write_req);
ffc1073c: 80 61 00 2c lwz r3,44(r1) <== NOT EXECUTED
ffc10740: 4b ff 55 dd bl ffc05d1c <free> <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
ffc10744: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc10748: 4b ff 9e 31 bl ffc0a578 <rtems_task_delete> <== NOT EXECUTED
}
ffc1074c: 80 01 00 7c lwz r0,124(r1) <== NOT EXECUTED
ffc10750: 82 21 00 3c lwz r17,60(r1) <== NOT EXECUTED
ffc10754: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc10758: 82 41 00 40 lwz r18,64(r1) <== NOT EXECUTED
ffc1075c: 82 61 00 44 lwz r19,68(r1) <== NOT EXECUTED
ffc10760: 82 81 00 48 lwz r20,72(r1) <== NOT EXECUTED
ffc10764: 82 a1 00 4c lwz r21,76(r1) <== NOT EXECUTED
ffc10768: 82 c1 00 50 lwz r22,80(r1) <== NOT EXECUTED
ffc1076c: 82 e1 00 54 lwz r23,84(r1) <== NOT EXECUTED
ffc10770: 83 01 00 58 lwz r24,88(r1) <== NOT EXECUTED
ffc10774: 83 21 00 5c lwz r25,92(r1) <== NOT EXECUTED
ffc10778: 83 41 00 60 lwz r26,96(r1) <== NOT EXECUTED
ffc1077c: 83 61 00 64 lwz r27,100(r1) <== NOT EXECUTED
ffc10780: 83 81 00 68 lwz r28,104(r1) <== NOT EXECUTED
ffc10784: 83 a1 00 6c lwz r29,108(r1) <== NOT EXECUTED
ffc10788: 83 c1 00 70 lwz r30,112(r1) <== NOT EXECUTED
ffc1078c: 83 e1 00 74 lwz r31,116(r1) <== NOT EXECUTED
ffc10790: 38 21 00 78 addi r1,r1,120 <== NOT EXECUTED
ffc10794: 4e 80 00 20 blr <== NOT EXECUTED
if (worker)
{
rtems_status_code sc = rtems_event_send (worker->id,
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WAKE);
ffc10798: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc1079c: 60 63 00 14 ori r3,r3,20 <== NOT EXECUTED
ffc107a0: 4b ff a3 11 bl ffc0aab0 <rtems_fatal_error_occurred> <== NOT EXECUTED
ffc107a4: 3f 80 00 00 lis r28,0
ffc107a8: 3b 9c 2a 08 addi r28,r28,10760
ffc107ac: 4b ff fd a0 b ffc1054c <rtems_bdbuf_swapout_task+0x174>
SWAPOUT_TASK_STACK_SIZE,
RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_CREATE);
ffc107b0: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc107b4: 60 63 00 16 ori r3,r3,22 <== NOT EXECUTED
ffc107b8: 4b ff a2 f9 bl ffc0aab0 <rtems_fatal_error_occurred> <== NOT EXECUTED
{
rtems_bdbuf_swapout_worker* worker;
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
if (!worker)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
ffc107bc: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc107c0: 60 63 00 15 ori r3,r3,21 <== NOT EXECUTED
ffc107c4: 4b ff a2 ed bl ffc0aab0 <rtems_fatal_error_occurred> <== NOT EXECUTED
sc = rtems_task_start (worker->id,
rtems_bdbuf_swapout_worker_task,
(rtems_task_argument) worker);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_START);
ffc107c8: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc107cc: 60 63 00 17 ori r3,r3,23 <== NOT EXECUTED
ffc107d0: 4b ff a2 e1 bl ffc0aab0 <rtems_fatal_error_occurred> <== NOT EXECUTED
ffc107d4 <rtems_bdbuf_swapout_worker_task>:
* @param arg A pointer to the worker thread's private data.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_worker_task (rtems_task_argument arg)
{
ffc107d4: 94 21 ff d8 stwu r1,-40(r1) <== NOT EXECUTED
ffc107d8: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc107dc: 90 01 00 2c stw r0,44(r1) <== NOT EXECUTED
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
while (worker->enabled)
ffc107e0: 88 03 00 0c lbz r0,12(r3) <== NOT EXECUTED
* @param arg A pointer to the worker thread's private data.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_worker_task (rtems_task_argument arg)
{
ffc107e4: 93 a1 00 1c stw r29,28(r1) <== NOT EXECUTED
ffc107e8: 7c 7d 1b 78 mr r29,r3 <== NOT EXECUTED
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
while (worker->enabled)
ffc107ec: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
* @param arg A pointer to the worker thread's private data.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_worker_task (rtems_task_argument arg)
{
ffc107f0: 93 21 00 0c stw r25,12(r1) <== NOT EXECUTED
ffc107f4: 93 41 00 10 stw r26,16(r1) <== NOT EXECUTED
ffc107f8: 93 61 00 14 stw r27,20(r1) <== NOT EXECUTED
ffc107fc: 93 81 00 18 stw r28,24(r1) <== NOT EXECUTED
ffc10800: 93 c1 00 20 stw r30,32(r1) <== NOT EXECUTED
ffc10804: 93 e1 00 24 stw r31,36(r1) <== NOT EXECUTED
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
while (worker->enabled)
ffc10808: 41 9e 00 64 beq- cr7,ffc1086c <rtems_bdbuf_swapout_worker_task+0x98><== NOT EXECUTED
ffc1080c: 3f 40 00 00 lis r26,0 <== NOT EXECUTED
ffc10810: 3b 83 00 10 addi r28,r3,16 <== NOT EXECUTED
ffc10814: 3b 23 00 14 addi r25,r3,20 <== NOT EXECUTED
ffc10818: 3b 5a 2a 10 addi r26,r26,10768 <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
ffc1081c: 3b 60 00 00 li r27,0 <== NOT EXECUTED
rtems_bdbuf_swapout_write (&worker->transfer);
rtems_bdbuf_lock_cache ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
ffc10820: 3b c0 ff ff li r30,-1 <== NOT EXECUTED
ffc10824: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
while (worker->enabled)
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);
ffc10828: 38 60 00 04 li r3,4 <== NOT EXECUTED
ffc1082c: 4b ff eb 11 bl ffc0f33c <rtems_bdbuf_wait_for_event> <== NOT EXECUTED
rtems_bdbuf_swapout_write (&worker->transfer);
ffc10830: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc10834: 4b ff f9 8d bl ffc101c0 <rtems_bdbuf_swapout_write> <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
ffc10838: 4b ff e7 61 bl ffc0ef98 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc1083c: 93 3d 00 10 stw r25,16(r29) <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
ffc10840: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
head->previous = NULL;
ffc10844: 93 7d 00 14 stw r27,20(r29) <== NOT EXECUTED
ffc10848: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
tail->previous = head;
ffc1084c: 93 9d 00 18 stw r28,24(r29) <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
ffc10850: 93 dd 00 20 stw r30,32(r29) <== NOT EXECUTED
ffc10854: 93 fd 00 24 stw r31,36(r29) <== NOT EXECUTED
ffc10858: 4b ff a9 21 bl ffc0b178 <_Chain_Append> <== NOT EXECUTED
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
ffc1085c: 4b ff e9 c9 bl ffc0f224 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
static rtems_task
rtems_bdbuf_swapout_worker_task (rtems_task_argument arg)
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
while (worker->enabled)
ffc10860: 88 1d 00 0c lbz r0,12(r29) <== NOT EXECUTED
ffc10864: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc10868: 40 9e ff c0 bne+ cr7,ffc10828 <rtems_bdbuf_swapout_worker_task+0x54><== NOT EXECUTED
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
}
free (worker->transfer.write_req);
ffc1086c: 80 7d 00 2c lwz r3,44(r29) <== NOT EXECUTED
ffc10870: 4b ff 54 ad bl ffc05d1c <free> <== NOT EXECUTED
free (worker);
ffc10874: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc10878: 4b ff 54 a5 bl ffc05d1c <free> <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
ffc1087c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc10880: 4b ff 9c f9 bl ffc0a578 <rtems_task_delete> <== NOT EXECUTED
}
ffc10884: 80 01 00 2c lwz r0,44(r1) <== NOT EXECUTED
ffc10888: 83 21 00 0c lwz r25,12(r1) <== NOT EXECUTED
ffc1088c: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc10890: 83 41 00 10 lwz r26,16(r1) <== NOT EXECUTED
ffc10894: 83 61 00 14 lwz r27,20(r1) <== NOT EXECUTED
ffc10898: 83 81 00 18 lwz r28,24(r1) <== NOT EXECUTED
ffc1089c: 83 a1 00 1c lwz r29,28(r1) <== NOT EXECUTED
ffc108a0: 83 c1 00 20 lwz r30,32(r1) <== NOT EXECUTED
ffc108a4: 83 e1 00 24 lwz r31,36(r1) <== NOT EXECUTED
ffc108a8: 38 21 00 28 addi r1,r1,40 <== NOT EXECUTED
ffc108ac: 4e 80 00 20 blr <== NOT EXECUTED
ffc101c0 <rtems_bdbuf_swapout_write>:
*
* @param transfer The transfer transaction.
*/
static void
rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer)
{
ffc101c0: 94 21 ff c8 stwu r1,-56(r1)
ffc101c4: 7c 08 02 a6 mflr r0
ffc101c8: 90 01 00 3c stw r0,60(r1)
printf ("bdbuf:swapout transfer: %08x\n", (unsigned) transfer->dev);
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
ffc101cc: 80 03 00 00 lwz r0,0(r3)
*
* @param transfer The transfer transaction.
*/
static void
rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer)
{
ffc101d0: 93 81 00 28 stw r28,40(r1)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
ffc101d4: 3b 83 00 04 addi r28,r3,4
printf ("bdbuf:swapout transfer: %08x\n", (unsigned) transfer->dev);
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
ffc101d8: 7f 80 e0 00 cmpw cr7,r0,r28
*
* @param transfer The transfer transaction.
*/
static void
rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer)
{
ffc101dc: 93 e1 00 34 stw r31,52(r1)
ffc101e0: 7c 7f 1b 78 mr r31,r3
ffc101e4: 92 a1 00 0c stw r21,12(r1)
ffc101e8: 92 c1 00 10 stw r22,16(r1)
ffc101ec: 92 e1 00 14 stw r23,20(r1)
ffc101f0: 93 01 00 18 stw r24,24(r1)
ffc101f4: 93 21 00 1c stw r25,28(r1)
ffc101f8: 93 41 00 20 stw r26,32(r1)
ffc101fc: 93 61 00 24 stw r27,36(r1)
ffc10200: 93 a1 00 2c stw r29,44(r1)
ffc10204: 93 c1 00 30 stw r30,48(r1)
printf ("bdbuf:swapout transfer: %08x\n", (unsigned) transfer->dev);
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
ffc10208: 41 9e 01 20 beq- cr7,ffc10328 <rtems_bdbuf_swapout_write+0x168><== NEVER TAKEN
/*
* Obtain the disk device. The cache's mutex has been released to avoid a
* dead lock.
*/
rtems_disk_device *dd = rtems_disk_obtain (transfer->dev);
ffc1020c: 80 63 00 10 lwz r3,16(r3)
if (dd == NULL)
dd = &null_disk;
ffc10210: 3e a0 00 00 lis r21,0
/*
* Obtain the disk device. The cache's mutex has been released to avoid a
* dead lock.
*/
rtems_disk_device *dd = rtems_disk_obtain (transfer->dev);
ffc10214: 80 9f 00 14 lwz r4,20(r31)
if (dd == NULL)
dd = &null_disk;
ffc10218: 3a b5 21 a0 addi r21,r21,8608
/*
* Obtain the disk device. The cache's mutex has been released to avoid a
* dead lock.
*/
rtems_disk_device *dd = rtems_disk_obtain (transfer->dev);
ffc1021c: 4b ff 4a 35 bl ffc04c50 <rtems_disk_obtain>
if (dd == NULL)
ffc10220: 7c 7e 1b 79 mr. r30,r3
ffc10224: 41 82 01 ac beq- ffc103d0 <rtems_bdbuf_swapout_write+0x210>
dd = &null_disk;
bufs_per_bd = dd->block_size / bdbuf_config.buffer_min;
ffc10228: 3f 60 ff c2 lis r27,-62
ffc1022c: 82 de 00 20 lwz r22,32(r30)
ffc10230: 3b 7b e1 74 addi r27,r27,-7820
* should be possible to make this change with little effect in this
* code. The array that is passed is broken in design and should be
* removed. Merging members of a struct into the first member is
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
ffc10234: 81 3f 00 1c lwz r9,28(r31)
rtems_disk_device *dd = rtems_disk_obtain (transfer->dev);
if (dd == NULL)
dd = &null_disk;
bufs_per_bd = dd->block_size / bdbuf_config.buffer_min;
ffc10238: 80 1b 00 20 lwz r0,32(r27)
{
/*
* The last block number used when the driver only supports
* continuous blocks in a single request.
*/
uint32_t last_block = 0;
ffc1023c: 3b a0 00 00 li r29,0
transfer->write_req->bufnum = 0;
while ((node = rtems_chain_get(&transfer->bds)) != NULL)
{
rtems_bdbuf_buffer* bd = (rtems_bdbuf_buffer*) node;
bool write = false;
ffc10240: 3a e0 00 00 li r23,0
rtems_disk_device *dd = rtems_disk_obtain (transfer->dev);
if (dd == NULL)
dd = &null_disk;
bufs_per_bd = dd->block_size / bdbuf_config.buffer_min;
ffc10244: 7e d6 03 96 divwu r22,r22,r0
* should be possible to make this change with little effect in this
* code. The array that is passed is broken in design and should be
* removed. Merging members of a struct into the first member is
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
ffc10248: 38 00 00 0c li r0,12
ffc1024c: 90 09 00 0c stw r0,12(r9)
transfer->write_req->bufnum = 0;
ffc10250: 38 00 00 00 li r0,0
rtems_bdbuf_purge_major (rtems_device_major_number major)
{
dev_t dev = rtems_filesystem_make_dev_t (major, 0);
rtems_bdbuf_purge (rtems_bdbuf_purge_compare_major, dev);
}
ffc10254: 3b 1e 00 08 addi r24,r30,8
* code. The array that is passed is broken in design and should be
* removed. Merging members of a struct into the first member is
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
transfer->write_req->bufnum = 0;
ffc10258: 90 09 00 10 stw r0,16(r9)
rtems_bdbuf_purge_major (rtems_device_major_number major)
{
dev_t dev = rtems_filesystem_make_dev_t (major, 0);
rtems_bdbuf_purge (rtems_bdbuf_purge_compare_major, dev);
}
ffc1025c: 3b 3e 00 28 addi r25,r30,40
if (write)
{
rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
ffc10260: 3b 40 00 0c li r26,12
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
ffc10264: 7f e3 fb 78 mr r3,r31
ffc10268: 4b ff af 69 bl ffc0b1d0 <_Chain_Get>
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
transfer->write_req->bufnum = 0;
while ((node = rtems_chain_get(&transfer->bds)) != NULL)
ffc1026c: 7c 64 1b 79 mr. r4,r3
ffc10270: 41 82 00 9c beq- ffc1030c <rtems_bdbuf_swapout_write+0x14c><== NEVER TAKEN
printf ("bdbuf:swapout write: bd:%" PRIu32 ", bufnum:%" PRIu32 " mode:%s\n",
bd->block, transfer->write_req->bufnum,
dd->phys_dev->capabilities &
RTEMS_BLKDEV_CAP_MULTISECTOR_CONT ? "MULIT" : "SCAT");
if ((dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) &&
ffc10274: 81 3e 00 08 lwz r9,8(r30)
transfer->write_req->bufnum &&
ffc10278: 80 bf 00 1c lwz r5,28(r31)
printf ("bdbuf:swapout write: bd:%" PRIu32 ", bufnum:%" PRIu32 " mode:%s\n",
bd->block, transfer->write_req->bufnum,
dd->phys_dev->capabilities &
RTEMS_BLKDEV_CAP_MULTISECTOR_CONT ? "MULIT" : "SCAT");
if ((dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) &&
ffc1027c: 80 09 00 0c lwz r0,12(r9)
ffc10280: 70 09 00 01 andi. r9,r0,1
ffc10284: 41 82 00 e0 beq- ffc10364 <rtems_bdbuf_swapout_write+0x1a4><== ALWAYS TAKEN
transfer->write_req->bufnum &&
ffc10288: 81 25 00 10 lwz r9,16(r5) <== NOT EXECUTED
printf ("bdbuf:swapout write: bd:%" PRIu32 ", bufnum:%" PRIu32 " mode:%s\n",
bd->block, transfer->write_req->bufnum,
dd->phys_dev->capabilities &
RTEMS_BLKDEV_CAP_MULTISECTOR_CONT ? "MULIT" : "SCAT");
if ((dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) &&
ffc1028c: 2f 89 00 00 cmpwi cr7,r9,0 <== NOT EXECUTED
ffc10290: 40 9e 00 ec bne- cr7,ffc1037c <rtems_bdbuf_swapout_write+0x1bc><== NOT EXECUTED
ffc10294: 83 a4 00 20 lwz r29,32(r4) <== NOT EXECUTED
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
ffc10298: 38 09 00 01 addi r0,r9,1
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
buf->length = dd->block_size;
ffc1029c: 81 1e 00 20 lwz r8,32(r30)
buf->buffer = bd->buffer;
ffc102a0: 81 44 00 24 lwz r10,36(r4)
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
ffc102a4: 54 0b 20 36 rlwinm r11,r0,4,0,27
ffc102a8: 7d 65 5a 14 add r11,r5,r11
transfer->write_req->bufnum++;
ffc102ac: 90 05 00 10 stw r0,16(r5)
transfer->write_req->bufnum = 0;
while ((node = rtems_chain_get(&transfer->bds)) != NULL)
{
rtems_bdbuf_buffer* bd = (rtems_bdbuf_buffer*) node;
bool write = false;
ffc102b0: 38 e0 00 00 li r7,0
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
transfer->write_req->bufnum++;
buf->user = bd;
ffc102b4: 90 8b 00 14 stw r4,20(r11)
buf->block = bd->block;
ffc102b8: 93 ab 00 08 stw r29,8(r11)
buf->length = dd->block_size;
ffc102bc: 91 0b 00 0c stw r8,12(r11)
buf->buffer = bd->buffer;
ffc102c0: 91 4b 00 10 stw r10,16(r11)
/*
* Perform the transfer if there are no more buffers, or the transfer
* size has reached the configured max. value.
*/
if (rtems_chain_is_empty (&transfer->bds) ||
ffc102c4: 80 1f 00 00 lwz r0,0(r31)
ffc102c8: 7f 9c 00 00 cmpw cr7,r28,r0
ffc102cc: 41 9e 00 14 beq- cr7,ffc102e0 <rtems_bdbuf_swapout_write+0x120>
ffc102d0: 81 25 00 10 lwz r9,16(r5)
ffc102d4: 80 1b 00 04 lwz r0,4(r27)
ffc102d8: 7f 89 00 40 cmplw cr7,r9,r0
ffc102dc: 41 9c 00 94 blt- cr7,ffc10370 <rtems_bdbuf_swapout_write+0x1b0>
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
write = true;
if (write)
{
rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
ffc102e0: 7f 24 cb 78 mr r4,r25
ffc102e4: 38 c0 00 00 li r6,0
ffc102e8: 7f 03 c3 78 mr r3,r24
ffc102ec: 4b ff fc c1 bl ffc0ffac <rtems_bdbuf_execute_transfer_request.isra.9>
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
ffc102f0: 81 3f 00 1c lwz r9,28(r31)
ffc102f4: 7f e3 fb 78 mr r3,r31
ffc102f8: 93 49 00 0c stw r26,12(r9)
transfer->write_req->bufnum = 0;
ffc102fc: 92 e9 00 10 stw r23,16(r9)
ffc10300: 4b ff ae d1 bl ffc0b1d0 <_Chain_Get>
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
transfer->write_req->bufnum = 0;
while ((node = rtems_chain_get(&transfer->bds)) != NULL)
ffc10304: 7c 64 1b 79 mr. r4,r3
ffc10308: 40 82 ff 6c bne+ ffc10274 <rtems_bdbuf_swapout_write+0xb4>
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
transfer->write_req->bufnum = 0;
}
}
if (dd != &null_disk)
ffc1030c: 7f 9e a8 00 cmpw cr7,r30,r21
ffc10310: 41 9e 00 18 beq- cr7,ffc10328 <rtems_bdbuf_swapout_write+0x168><== NEVER TAKEN
{
/*
* If sync'ing and the deivce is capability of handling a sync IO control
* call perform the call.
*/
if (transfer->syncing &&
ffc10314: 88 1f 00 18 lbz r0,24(r31)
ffc10318: 2f 80 00 00 cmpwi cr7,r0,0
ffc1031c: 40 9e 00 8c bne- cr7,ffc103a8 <rtems_bdbuf_swapout_write+0x1e8>
{
/* int result = */ dd->ioctl (dd->phys_dev, RTEMS_BLKDEV_REQ_SYNC, NULL);
/* How should the error be handled ? */
}
rtems_disk_release (dd);
ffc10320: 7f c3 f3 78 mr r3,r30
ffc10324: 4b ff 49 e1 bl ffc04d04 <rtems_disk_release>
}
}
}
ffc10328: 80 01 00 3c lwz r0,60(r1)
ffc1032c: 82 a1 00 0c lwz r21,12(r1)
ffc10330: 7c 08 03 a6 mtlr r0
ffc10334: 82 c1 00 10 lwz r22,16(r1)
ffc10338: 82 e1 00 14 lwz r23,20(r1)
ffc1033c: 83 01 00 18 lwz r24,24(r1)
ffc10340: 83 21 00 1c lwz r25,28(r1)
ffc10344: 83 41 00 20 lwz r26,32(r1)
ffc10348: 83 61 00 24 lwz r27,36(r1)
ffc1034c: 83 81 00 28 lwz r28,40(r1)
ffc10350: 83 a1 00 2c lwz r29,44(r1)
ffc10354: 83 c1 00 30 lwz r30,48(r1)
ffc10358: 83 e1 00 34 lwz r31,52(r1)
ffc1035c: 38 21 00 38 addi r1,r1,56
ffc10360: 4e 80 00 20 blr
if ((dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) &&
transfer->write_req->bufnum &&
(bd->block != (last_block + bufs_per_bd)))
{
rtems_chain_prepend (&transfer->bds, &bd->link);
write = true;
ffc10364: 83 a4 00 20 lwz r29,32(r4)
ffc10368: 81 25 00 10 lwz r9,16(r5)
ffc1036c: 4b ff ff 2c b ffc10298 <rtems_bdbuf_swapout_write+0xd8>
if (rtems_chain_is_empty (&transfer->bds) ||
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
write = true;
if (write)
ffc10370: 2f 87 00 00 cmpwi cr7,r7,0
ffc10374: 41 9e fe f0 beq+ cr7,ffc10264 <rtems_bdbuf_swapout_write+0xa4><== ALWAYS TAKEN
ffc10378: 4b ff ff 68 b ffc102e0 <rtems_bdbuf_swapout_write+0x120><== NOT EXECUTED
dd->phys_dev->capabilities &
RTEMS_BLKDEV_CAP_MULTISECTOR_CONT ? "MULIT" : "SCAT");
if ((dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) &&
transfer->write_req->bufnum &&
(bd->block != (last_block + bufs_per_bd)))
ffc1037c: 80 04 00 20 lwz r0,32(r4) <== NOT EXECUTED
ffc10380: 7d 7d b2 14 add r11,r29,r22 <== NOT EXECUTED
bd->block, transfer->write_req->bufnum,
dd->phys_dev->capabilities &
RTEMS_BLKDEV_CAP_MULTISECTOR_CONT ? "MULIT" : "SCAT");
if ((dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) &&
transfer->write_req->bufnum &&
ffc10384: 7f 80 58 00 cmpw cr7,r0,r11 <== NOT EXECUTED
ffc10388: 41 9e 00 18 beq- cr7,ffc103a0 <rtems_bdbuf_swapout_write+0x1e0><== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
ffc1038c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc10390: 48 00 51 b5 bl ffc15544 <_Chain_Insert> <== NOT EXECUTED
ffc10394: 80 bf 00 1c lwz r5,28(r31) <== NOT EXECUTED
(bd->block != (last_block + bufs_per_bd)))
{
rtems_chain_prepend (&transfer->bds, &bd->link);
write = true;
ffc10398: 38 e0 00 01 li r7,1 <== NOT EXECUTED
ffc1039c: 4b ff ff 28 b ffc102c4 <rtems_bdbuf_swapout_write+0x104><== NOT EXECUTED
bd->block, transfer->write_req->bufnum,
dd->phys_dev->capabilities &
RTEMS_BLKDEV_CAP_MULTISECTOR_CONT ? "MULIT" : "SCAT");
if ((dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) &&
transfer->write_req->bufnum &&
ffc103a0: 7c 1d 03 78 mr r29,r0 <== NOT EXECUTED
ffc103a4: 4b ff fe f4 b ffc10298 <rtems_bdbuf_swapout_write+0xd8><== NOT EXECUTED
/*
* If sync'ing and the deivce is capability of handling a sync IO control
* call perform the call.
*/
if (transfer->syncing &&
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
ffc103a8: 80 7e 00 08 lwz r3,8(r30)
ffc103ac: 80 03 00 0c lwz r0,12(r3)
{
/*
* If sync'ing and the deivce is capability of handling a sync IO control
* call perform the call.
*/
if (transfer->syncing &&
ffc103b0: 70 09 00 02 andi. r9,r0,2
ffc103b4: 41 82 ff 6c beq+ ffc10320 <rtems_bdbuf_swapout_write+0x160><== ALWAYS TAKEN
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
{
/* int result = */ dd->ioctl (dd->phys_dev, RTEMS_BLKDEV_REQ_SYNC, NULL);
ffc103b8: 80 1e 00 28 lwz r0,40(r30) <== NOT EXECUTED
ffc103bc: 38 80 00 02 li r4,2 <== NOT EXECUTED
ffc103c0: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc103c4: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc103c8: 4e 80 04 21 bctrl <== NOT EXECUTED
ffc103cc: 4b ff ff 54 b ffc10320 <rtems_bdbuf_swapout_write+0x160><== NOT EXECUTED
* dead lock.
*/
rtems_disk_device *dd = rtems_disk_obtain (transfer->dev);
if (dd == NULL)
dd = &null_disk;
ffc103d0: 7e be ab 78 mr r30,r21
ffc103d4: 4b ff fe 54 b ffc10228 <rtems_bdbuf_swapout_write+0x68>
ffc0f52c <rtems_bdbuf_swapout_writereq_alloc>:
* have been a rtems_chain_control. Simple, fast and less storage as the node
* is already part of the buffer structure.
*/
rtems_blkdev_request* write_req =
malloc (sizeof (rtems_blkdev_request) +
(bdbuf_config.max_write_blocks * sizeof (rtems_blkdev_sg_buffer)));
ffc0f52c: 3d 20 ff c2 lis r9,-62
*
* @return rtems_blkdev_request* The write reference memory.
*/
static rtems_blkdev_request*
rtems_bdbuf_swapout_writereq_alloc (void)
{
ffc0f530: 94 21 ff f0 stwu r1,-16(r1)
ffc0f534: 7c 08 02 a6 mflr r0
* have been a rtems_chain_control. Simple, fast and less storage as the node
* is already part of the buffer structure.
*/
rtems_blkdev_request* write_req =
malloc (sizeof (rtems_blkdev_request) +
(bdbuf_config.max_write_blocks * sizeof (rtems_blkdev_sg_buffer)));
ffc0f538: 80 69 e1 78 lwz r3,-7816(r9)
*
* @return rtems_blkdev_request* The write reference memory.
*/
static rtems_blkdev_request*
rtems_bdbuf_swapout_writereq_alloc (void)
{
ffc0f53c: 93 e1 00 0c stw r31,12(r1)
* have been a rtems_chain_control. Simple, fast and less storage as the node
* is already part of the buffer structure.
*/
rtems_blkdev_request* write_req =
malloc (sizeof (rtems_blkdev_request) +
(bdbuf_config.max_write_blocks * sizeof (rtems_blkdev_sg_buffer)));
ffc0f540: 54 63 20 36 rlwinm r3,r3,4,0,27
* @note chrisj The rtems_blkdev_request and the array at the end is a hack.
* I am disappointment at finding code like this in RTEMS. The request should
* have been a rtems_chain_control. Simple, fast and less storage as the node
* is already part of the buffer structure.
*/
rtems_blkdev_request* write_req =
ffc0f544: 38 63 00 18 addi r3,r3,24
*
* @return rtems_blkdev_request* The write reference memory.
*/
static rtems_blkdev_request*
rtems_bdbuf_swapout_writereq_alloc (void)
{
ffc0f548: 90 01 00 14 stw r0,20(r1)
* @note chrisj The rtems_blkdev_request and the array at the end is a hack.
* I am disappointment at finding code like this in RTEMS. The request should
* have been a rtems_chain_control. Simple, fast and less storage as the node
* is already part of the buffer structure.
*/
rtems_blkdev_request* write_req =
ffc0f54c: 4b ff 6b ed bl ffc06138 <malloc>
malloc (sizeof (rtems_blkdev_request) +
(bdbuf_config.max_write_blocks * sizeof (rtems_blkdev_sg_buffer)));
if (!write_req)
ffc0f550: 7c 7f 1b 79 mr. r31,r3
ffc0f554: 41 82 00 3c beq- ffc0f590 <rtems_bdbuf_swapout_writereq_alloc+0x64><== NEVER TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
write_req->req = RTEMS_BLKDEV_REQ_WRITE;
ffc0f558: 38 00 00 01 li r0,1
write_req->req_done = rtems_bdbuf_transfer_done;
write_req->done_arg = write_req;
ffc0f55c: 93 ff 00 08 stw r31,8(r31)
if (!write_req)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
write_req->req = RTEMS_BLKDEV_REQ_WRITE;
write_req->req_done = rtems_bdbuf_transfer_done;
ffc0f560: 3d 20 ff c1 lis r9,-63
(bdbuf_config.max_write_blocks * sizeof (rtems_blkdev_sg_buffer)));
if (!write_req)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
write_req->req = RTEMS_BLKDEV_REQ_WRITE;
ffc0f564: 90 1f 00 00 stw r0,0(r31)
write_req->req_done = rtems_bdbuf_transfer_done;
ffc0f568: 38 09 f3 10 addi r0,r9,-3312
ffc0f56c: 90 1f 00 04 stw r0,4(r31)
write_req->done_arg = write_req;
write_req->io_task = rtems_task_self ();
ffc0f570: 48 00 5b c5 bl ffc15134 <rtems_task_self>
return write_req;
}
ffc0f574: 80 01 00 14 lwz r0,20(r1)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
write_req->req = RTEMS_BLKDEV_REQ_WRITE;
write_req->req_done = rtems_bdbuf_transfer_done;
write_req->done_arg = write_req;
write_req->io_task = rtems_task_self ();
ffc0f578: 90 7f 00 14 stw r3,20(r31)
return write_req;
}
ffc0f57c: 7f e3 fb 78 mr r3,r31
ffc0f580: 7c 08 03 a6 mtlr r0
ffc0f584: 83 e1 00 0c lwz r31,12(r1)
ffc0f588: 38 21 00 10 addi r1,r1,16
ffc0f58c: 4e 80 00 20 blr
rtems_blkdev_request* write_req =
malloc (sizeof (rtems_blkdev_request) +
(bdbuf_config.max_write_blocks * sizeof (rtems_blkdev_sg_buffer)));
if (!write_req)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
ffc0f590: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0f594: 60 63 00 15 ori r3,r3,21 <== NOT EXECUTED
ffc0f598: 4b ff b5 19 bl ffc0aab0 <rtems_fatal_error_occurred> <== NOT EXECUTED
ffc119e0 <rtems_bdbuf_sync>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_sync (rtems_bdbuf_buffer *bd)
{
ffc119e0: 94 21 ff e8 stwu r1,-24(r1)
ffc119e4: 7c 08 02 a6 mflr r0
ffc119e8: 93 c1 00 10 stw r30,16(r1)
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
ffc119ec: 3f c0 00 00 lis r30,0
ffc119f0: 3b de 2a 08 addi r30,r30,10760
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_sync (rtems_bdbuf_buffer *bd)
{
ffc119f4: 90 01 00 1c stw r0,28(r1)
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
ffc119f8: 88 1e 00 88 lbz r0,136(r30)
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_sync (rtems_bdbuf_buffer *bd)
{
ffc119fc: 93 e1 00 14 stw r31,20(r1)
ffc11a00: 7c 7f 1b 78 mr r31,r3
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
ffc11a04: 2f 80 00 00 cmpwi cr7,r0,0
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_sync (rtems_bdbuf_buffer *bd)
{
ffc11a08: 93 a1 00 0c stw r29,12(r1)
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
return RTEMS_NOT_CONFIGURED;
ffc11a0c: 38 60 00 16 li r3,22
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
ffc11a10: 41 9e 00 4c beq- cr7,ffc11a5c <rtems_bdbuf_sync+0x7c> <== NEVER TAKEN
return RTEMS_NOT_CONFIGURED;
if (bd == NULL)
ffc11a14: 2f 9f 00 00 cmpwi cr7,r31,0
ffc11a18: 41 9e 00 60 beq- cr7,ffc11a78 <rtems_bdbuf_sync+0x98> <== NEVER TAKEN
if (rtems_bdbuf_tracer)
{
printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);
rtems_bdbuf_show_users (kind, bd);
}
rtems_bdbuf_lock_cache();
ffc11a1c: 4b ff d5 7d bl ffc0ef98 <rtems_bdbuf_lock_cache>
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "sync");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
ffc11a20: 80 1f 00 28 lwz r0,40(r31)
ffc11a24: 2b 80 00 03 cmplwi cr7,r0,3
ffc11a28: 41 9c 00 14 blt- cr7,ffc11a3c <rtems_bdbuf_sync+0x5c> <== NEVER TAKEN
ffc11a2c: 2b 80 00 05 cmplwi cr7,r0,5
ffc11a30: 40 9d 00 68 ble- cr7,ffc11a98 <rtems_bdbuf_sync+0xb8>
ffc11a34: 2f 80 00 06 cmpwi cr7,r0,6
ffc11a38: 41 9e 00 14 beq- cr7,ffc11a4c <rtems_bdbuf_sync+0x6c> <== ALWAYS TAKEN
break;
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_5);
ffc11a3c: 3c 80 42 00 lis r4,16896 <== NOT EXECUTED
ffc11a40: 80 7f 00 28 lwz r3,40(r31) <== NOT EXECUTED
ffc11a44: 60 84 00 03 ori r4,r4,3 <== NOT EXECUTED
ffc11a48: 4b ff d5 d9 bl ffc0f020 <rtems_bdbuf_fatal> <== NOT EXECUTED
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_sync_after_access (bd);
break;
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
ffc11a4c: 7f e3 fb 78 mr r3,r31
ffc11a50: 4b ff e2 81 bl ffc0fcd0 <rtems_bdbuf_discard_buffer_after_access>
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
ffc11a54: 4b ff d7 d1 bl ffc0f224 <rtems_bdbuf_unlock_cache>
return RTEMS_SUCCESSFUL;
ffc11a58: 38 60 00 00 li r3,0
}
ffc11a5c: 80 01 00 1c lwz r0,28(r1)
ffc11a60: 83 a1 00 0c lwz r29,12(r1)
ffc11a64: 7c 08 03 a6 mtlr r0
ffc11a68: 83 c1 00 10 lwz r30,16(r1)
ffc11a6c: 83 e1 00 14 lwz r31,20(r1)
ffc11a70: 38 21 00 18 addi r1,r1,24
ffc11a74: 4e 80 00 20 blr
ffc11a78: 80 01 00 1c lwz r0,28(r1) <== NOT EXECUTED
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
return RTEMS_NOT_CONFIGURED;
if (bd == NULL)
return RTEMS_INVALID_ADDRESS;
ffc11a7c: 38 60 00 09 li r3,9 <== NOT EXECUTED
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
return RTEMS_SUCCESSFUL;
}
ffc11a80: 83 a1 00 0c lwz r29,12(r1) <== NOT EXECUTED
ffc11a84: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc11a88: 83 c1 00 10 lwz r30,16(r1) <== NOT EXECUTED
ffc11a8c: 83 e1 00 14 lwz r31,20(r1) <== NOT EXECUTED
ffc11a90: 38 21 00 18 addi r1,r1,24 <== NOT EXECUTED
ffc11a94: 4e 80 00 20 blr <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc11a98: 38 00 00 08 li r0,8
ffc11a9c: 90 1f 00 28 stw r0,40(r31)
ffc11aa0: 38 7e 00 5c addi r3,r30,92
ffc11aa4: 7f e4 fb 78 mr r4,r31
ffc11aa8: 4b ff 96 d1 bl ffc0b178 <_Chain_Append>
{
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_append (&bdbuf_cache.sync, &bd->link);
if (bd->waiters)
ffc11aac: 80 1f 00 2c lwz r0,44(r31)
ffc11ab0: 2f 80 00 00 cmpwi cr7,r0,0
ffc11ab4: 40 9e 00 84 bne- cr7,ffc11b38 <rtems_bdbuf_sync+0x158>
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
rtems_bdbuf_wake_swapper ();
ffc11ab8: 4b ff d8 19 bl ffc0f2d0 <rtems_bdbuf_wake_swapper>
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
return;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
ffc11abc: 3b be 00 70 addi r29,r30,112
static void
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
ffc11ac0: 80 1f 00 28 lwz r0,40(r31)
ffc11ac4: 2b 80 00 01 cmplwi cr7,r0,1
ffc11ac8: 40 9c 00 14 bge- cr7,ffc11adc <rtems_bdbuf_sync+0xfc> <== ALWAYS TAKEN
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_9);
ffc11acc: 3c 80 42 00 lis r4,16896 <== NOT EXECUTED
ffc11ad0: 80 7f 00 28 lwz r3,40(r31) <== NOT EXECUTED
ffc11ad4: 60 84 00 07 ori r4,r4,7 <== NOT EXECUTED
ffc11ad8: 4b ff d5 49 bl ffc0f020 <rtems_bdbuf_fatal> <== NOT EXECUTED
static void
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
ffc11adc: 2b 80 00 07 cmplwi cr7,r0,7
ffc11ae0: 40 9d 00 1c ble- cr7,ffc11afc <rtems_bdbuf_sync+0x11c>
ffc11ae4: 2b 80 00 0a cmplwi cr7,r0,10
ffc11ae8: 41 bd ff e4 bgt- cr7,ffc11acc <rtems_bdbuf_sync+0xec> <== NEVER TAKEN
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
return;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
ffc11aec: 7f e3 fb 78 mr r3,r31
ffc11af0: 7f a4 eb 78 mr r4,r29
ffc11af4: 4b ff d9 d1 bl ffc0f4c4 <rtems_bdbuf_wait>
ffc11af8: 4b ff ff c8 b ffc11ac0 <rtems_bdbuf_sync+0xe0>
rtems_bdbuf_wait_for_sync_done (bd);
/*
* We may have created a cached or empty buffer which may be recycled.
*/
if (bd->waiters == 0
ffc11afc: 80 1f 00 2c lwz r0,44(r31)
ffc11b00: 2f 80 00 00 cmpwi cr7,r0,0
ffc11b04: 40 be ff 50 bne- cr7,ffc11a54 <rtems_bdbuf_sync+0x74>
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
ffc11b08: 80 1f 00 28 lwz r0,40(r31)
ffc11b0c: 2f 80 00 02 cmpwi cr7,r0,2
ffc11b10: 41 9e 00 10 beq- cr7,ffc11b20 <rtems_bdbuf_sync+0x140>
|| bd->state == RTEMS_BDBUF_STATE_EMPTY))
ffc11b14: 80 1f 00 28 lwz r0,40(r31)
ffc11b18: 2f 80 00 01 cmpwi cr7,r0,1
ffc11b1c: 40 9e ff 38 bne+ cr7,ffc11a54 <rtems_bdbuf_sync+0x74> <== NEVER TAKEN
{
if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
ffc11b20: 80 1f 00 28 lwz r0,40(r31)
ffc11b24: 2f 80 00 01 cmpwi cr7,r0,1
ffc11b28: 41 9e 00 1c beq- cr7,ffc11b44 <rtems_bdbuf_sync+0x164>
{
rtems_bdbuf_remove_from_tree (bd);
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
}
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
ffc11b2c: 38 7e 00 78 addi r3,r30,120
ffc11b30: 4b ff da 6d bl ffc0f59c <rtems_bdbuf_wake>
ffc11b34: 4b ff ff 20 b ffc11a54 <rtems_bdbuf_sync+0x74>
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_append (&bdbuf_cache.sync, &bd->link);
if (bd->waiters)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
ffc11b38: 38 7e 00 68 addi r3,r30,104
ffc11b3c: 4b ff da 61 bl ffc0f59c <rtems_bdbuf_wake>
ffc11b40: 4b ff ff 78 b ffc11ab8 <rtems_bdbuf_sync+0xd8>
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
|| bd->state == RTEMS_BDBUF_STATE_EMPTY))
{
if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
{
rtems_bdbuf_remove_from_tree (bd);
ffc11b44: 7f e3 fb 78 mr r3,r31
ffc11b48: 4b ff dc f5 bl ffc0f83c <rtems_bdbuf_remove_from_tree>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc11b4c: 38 00 00 00 li r0,0
ffc11b50: 90 1f 00 28 stw r0,40(r31)
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
ffc11b54: 38 7e 00 44 addi r3,r30,68
ffc11b58: 7f e4 fb 78 mr r4,r31
ffc11b5c: 48 00 39 e9 bl ffc15544 <_Chain_Insert>
ffc11b60: 4b ff ff cc b ffc11b2c <rtems_bdbuf_sync+0x14c>
ffc11b64 <rtems_bdbuf_syncdev>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_syncdev (dev_t dev)
{
ffc11b64: 94 21 ff d8 stwu r1,-40(r1)
ffc11b68: 7c 08 02 a6 mflr r0
ffc11b6c: 93 a1 00 1c stw r29,28(r1)
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
ffc11b70: 3f a0 00 00 lis r29,0
ffc11b74: 3b bd 2a 08 addi r29,r29,10760
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_syncdev (dev_t dev)
{
ffc11b78: 90 01 00 2c stw r0,44(r1)
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
ffc11b7c: 88 1d 00 88 lbz r0,136(r29)
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_syncdev (dev_t dev)
{
ffc11b80: 93 81 00 18 stw r28,24(r1)
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
return RTEMS_NOT_CONFIGURED;
ffc11b84: 3b 80 00 16 li r28,22
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
ffc11b88: 2f 80 00 00 cmpwi cr7,r0,0
rtems_status_code
rtems_bdbuf_syncdev (dev_t dev)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
ffc11b8c: 38 00 00 00 li r0,0
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_syncdev (dev_t dev)
{
ffc11b90: 93 c1 00 20 stw r30,32(r1)
ffc11b94: 7c 7e 1b 78 mr r30,r3
ffc11b98: 93 e1 00 24 stw r31,36(r1)
ffc11b9c: 7c 9f 23 78 mr r31,r4
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
ffc11ba0: 90 01 00 08 stw r0,8(r1)
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
ffc11ba4: 40 9e 00 28 bne- cr7,ffc11bcc <rtems_bdbuf_syncdev+0x68><== ALWAYS TAKEN
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_TRANSFER_SYNC);
rtems_bdbuf_unlock_sync ();
rtems_bdbuf_release_disk (dd);
return RTEMS_SUCCESSFUL;
}
ffc11ba8: 80 01 00 2c lwz r0,44(r1) <== NOT EXECUTED
ffc11bac: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc11bb0: 83 a1 00 1c lwz r29,28(r1) <== NOT EXECUTED
ffc11bb4: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc11bb8: 83 81 00 18 lwz r28,24(r1) <== NOT EXECUTED
ffc11bbc: 83 c1 00 20 lwz r30,32(r1) <== NOT EXECUTED
ffc11bc0: 83 e1 00 24 lwz r31,36(r1) <== NOT EXECUTED
ffc11bc4: 38 21 00 28 addi r1,r1,40 <== NOT EXECUTED
ffc11bc8: 4e 80 00 20 blr <== NOT EXECUTED
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
ffc11bcc: 38 a0 00 00 li r5,0
ffc11bd0: 38 c1 00 08 addi r6,r1,8
ffc11bd4: 38 e0 00 00 li r7,0
ffc11bd8: 39 00 00 00 li r8,0
ffc11bdc: 4b ff db 21 bl ffc0f6fc <rtems_bdbuf_obtain_disk.part.8>
if (rtems_bdbuf_tracer)
printf ("bdbuf:syncdev: %08x\n", (unsigned) dev);
sc = rtems_bdbuf_obtain_disk (dev, 0, &dd, NULL, NULL);
if (sc != RTEMS_SUCCESSFUL)
ffc11be0: 7c 7c 1b 79 mr. r28,r3
ffc11be4: 40 a2 ff c4 bne- ffc11ba8 <rtems_bdbuf_syncdev+0x44> <== NEVER TAKEN
* Take the sync lock before locking the cache. Once we have the sync lock we
* can lock the cache. If another thread has the sync lock it will cause this
* thread to block until it owns the sync lock then it can own the cache. The
* sync lock can only be obtained with the cache unlocked.
*/
rtems_bdbuf_lock_sync ();
ffc11be8: 4b ff d3 f5 bl ffc0efdc <rtems_bdbuf_lock_sync>
rtems_bdbuf_lock_cache ();
ffc11bec: 4b ff d3 ad bl ffc0ef98 <rtems_bdbuf_lock_cache>
* out task know the id of the requester to wake when done.
*
* The swap out task will negate the sync active flag when no more buffers
* for the device are held on the "modified for sync" queues.
*/
bdbuf_cache.sync_active = true;
ffc11bf0: 38 00 00 01 li r0,1
ffc11bf4: 98 1d 00 30 stb r0,48(r29)
bdbuf_cache.sync_requester = rtems_task_self ();
ffc11bf8: 48 00 35 3d bl ffc15134 <rtems_task_self>
ffc11bfc: 90 7d 00 34 stw r3,52(r29)
bdbuf_cache.sync_device = dev;
ffc11c00: 93 dd 00 38 stw r30,56(r29)
ffc11c04: 93 fd 00 3c stw r31,60(r29)
rtems_bdbuf_wake_swapper ();
ffc11c08: 4b ff d6 c9 bl ffc0f2d0 <rtems_bdbuf_wake_swapper>
rtems_bdbuf_unlock_cache ();
ffc11c0c: 4b ff d6 19 bl ffc0f224 <rtems_bdbuf_unlock_cache>
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_TRANSFER_SYNC);
ffc11c10: 38 60 00 02 li r3,2
ffc11c14: 4b ff d7 29 bl ffc0f33c <rtems_bdbuf_wait_for_event>
rtems_bdbuf_unlock_sync ();
ffc11c18: 4b ff d6 49 bl ffc0f260 <rtems_bdbuf_unlock_sync>
rtems_bdbuf_release_disk (dd);
ffc11c1c: 80 61 00 08 lwz r3,8(r1)
ffc11c20: 4b ff d6 7d bl ffc0f29c <rtems_bdbuf_release_disk>
return RTEMS_SUCCESSFUL;
}
ffc11c24: 80 01 00 2c lwz r0,44(r1)
ffc11c28: 7f 83 e3 78 mr r3,r28
ffc11c2c: 83 a1 00 1c lwz r29,28(r1)
ffc11c30: 7c 08 03 a6 mtlr r0
ffc11c34: 83 81 00 18 lwz r28,24(r1)
ffc11c38: 83 c1 00 20 lwz r30,32(r1)
ffc11c3c: 83 e1 00 24 lwz r31,36(r1)
ffc11c40: 38 21 00 28 addi r1,r1,40
ffc11c44: 4e 80 00 20 blr
ffc0f224 <rtems_bdbuf_unlock_cache>:
* Unlock the cache.
*/
static void
rtems_bdbuf_unlock_cache (void)
{
rtems_bdbuf_unlock (bdbuf_cache.lock, RTEMS_BLKDEV_FATAL_BDBUF_CACHE_UNLOCK);
ffc0f224: 3d 20 00 00 lis r9,0
/**
* Unlock the cache.
*/
static void
rtems_bdbuf_unlock_cache (void)
{
ffc0f228: 94 21 ff f8 stwu r1,-8(r1)
ffc0f22c: 7c 08 02 a6 mflr r0
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_unlock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_release (lock);
ffc0f230: 80 69 2a 30 lwz r3,10800(r9)
/**
* Unlock the cache.
*/
static void
rtems_bdbuf_unlock_cache (void)
{
ffc0f234: 90 01 00 0c stw r0,12(r1)
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_unlock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_release (lock);
ffc0f238: 4b ff b0 e9 bl ffc0a320 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc0f23c: 2f 83 00 00 cmpwi cr7,r3,0
ffc0f240: 40 9e 00 14 bne- cr7,ffc0f254 <rtems_bdbuf_unlock_cache+0x30><== NEVER TAKEN
*/
static void
rtems_bdbuf_unlock_cache (void)
{
rtems_bdbuf_unlock (bdbuf_cache.lock, RTEMS_BLKDEV_FATAL_BDBUF_CACHE_UNLOCK);
}
ffc0f244: 80 01 00 0c lwz r0,12(r1)
ffc0f248: 38 21 00 08 addi r1,r1,8
ffc0f24c: 7c 08 03 a6 mtlr r0
ffc0f250: 4e 80 00 20 blr
static void
rtems_bdbuf_unlock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_release (lock);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (fatal_error_code);
ffc0f254: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0f258: 60 63 00 0e ori r3,r3,14 <== NOT EXECUTED
ffc0f25c: 4b ff b8 55 bl ffc0aab0 <rtems_fatal_error_occurred> <== NOT EXECUTED
ffc0f260 <rtems_bdbuf_unlock_sync>:
* Unlock the cache's sync lock. Any blocked writers are woken.
*/
static void
rtems_bdbuf_unlock_sync (void)
{
rtems_bdbuf_unlock (bdbuf_cache.sync_lock,
ffc0f260: 3d 20 00 00 lis r9,0
/**
* Unlock the cache's sync lock. Any blocked writers are woken.
*/
static void
rtems_bdbuf_unlock_sync (void)
{
ffc0f264: 94 21 ff f8 stwu r1,-8(r1)
ffc0f268: 7c 08 02 a6 mflr r0
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_unlock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_release (lock);
ffc0f26c: 80 69 2a 34 lwz r3,10804(r9)
/**
* Unlock the cache's sync lock. Any blocked writers are woken.
*/
static void
rtems_bdbuf_unlock_sync (void)
{
ffc0f270: 90 01 00 0c stw r0,12(r1)
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_unlock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_release (lock);
ffc0f274: 4b ff b0 ad bl ffc0a320 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc0f278: 2f 83 00 00 cmpwi cr7,r3,0
ffc0f27c: 40 9e 00 14 bne- cr7,ffc0f290 <rtems_bdbuf_unlock_sync+0x30><== NEVER TAKEN
static void
rtems_bdbuf_unlock_sync (void)
{
rtems_bdbuf_unlock (bdbuf_cache.sync_lock,
RTEMS_BLKDEV_FATAL_BDBUF_SYNC_UNLOCK);
}
ffc0f280: 80 01 00 0c lwz r0,12(r1)
ffc0f284: 38 21 00 08 addi r1,r1,8
ffc0f288: 7c 08 03 a6 mtlr r0
ffc0f28c: 4e 80 00 20 blr
static void
rtems_bdbuf_unlock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_release (lock);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (fatal_error_code);
ffc0f290: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0f294: 60 63 00 0c ori r3,r3,12 <== NOT EXECUTED
ffc0f298: 4b ff b8 19 bl ffc0aab0 <rtems_fatal_error_occurred> <== NOT EXECUTED
ffc0f33c <rtems_bdbuf_wait_for_event>:
return RTEMS_UNSATISFIED;
}
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
ffc0f33c: 94 21 ff e0 stwu r1,-32(r1)
ffc0f340: 7c 08 02 a6 mflr r0
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_event_set out = 0;
sc = rtems_event_receive (event,
ffc0f344: 38 80 00 00 li r4,0
return RTEMS_UNSATISFIED;
}
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
ffc0f348: 90 01 00 24 stw r0,36(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_event_set out = 0;
ffc0f34c: 7c 26 0b 78 mr r6,r1
ffc0f350: 38 00 00 00 li r0,0
return RTEMS_UNSATISFIED;
}
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
ffc0f354: 93 e1 00 1c stw r31,28(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_event_set out = 0;
sc = rtems_event_receive (event,
ffc0f358: 38 a0 00 00 li r5,0
return RTEMS_UNSATISFIED;
}
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
ffc0f35c: 7c 7f 1b 78 mr r31,r3
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_event_set out = 0;
ffc0f360: 94 06 00 08 stwu r0,8(r6)
sc = rtems_event_receive (event,
ffc0f364: 4b ff a6 d5 bl ffc09a38 <rtems_event_receive>
RTEMS_EVENT_ALL | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&out);
if (sc != RTEMS_SUCCESSFUL || out != event)
ffc0f368: 2f 83 00 00 cmpwi cr7,r3,0
ffc0f36c: 40 9e 00 24 bne- cr7,ffc0f390 <rtems_bdbuf_wait_for_event+0x54><== NEVER TAKEN
ffc0f370: 80 01 00 08 lwz r0,8(r1)
ffc0f374: 7f 80 f8 00 cmpw cr7,r0,r31
ffc0f378: 40 9e 00 18 bne- cr7,ffc0f390 <rtems_bdbuf_wait_for_event+0x54><== NEVER TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_WAIT_EVNT);
}
ffc0f37c: 80 01 00 24 lwz r0,36(r1)
ffc0f380: 83 e1 00 1c lwz r31,28(r1)
ffc0f384: 38 21 00 20 addi r1,r1,32
ffc0f388: 7c 08 03 a6 mtlr r0
ffc0f38c: 4e 80 00 20 blr
RTEMS_EVENT_ALL | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&out);
if (sc != RTEMS_SUCCESSFUL || out != event)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_WAIT_EVNT);
ffc0f390: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0f394: 60 63 00 1a ori r3,r3,26 <== NOT EXECUTED
ffc0f398: 4b ff b7 19 bl ffc0aab0 <rtems_fatal_error_occurred> <== NOT EXECUTED
ffc0f59c <rtems_bdbuf_wake>:
* Wake a blocked resource. The resource has a counter that lets us know if
* there are any waiters.
*/
static void
rtems_bdbuf_wake (const rtems_bdbuf_waiters *waiters)
{
ffc0f59c: 7c 08 02 a6 mflr r0
ffc0f5a0: 94 21 ff f8 stwu r1,-8(r1)
ffc0f5a4: 90 01 00 0c stw r0,12(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (waiters->count > 0)
ffc0f5a8: 80 03 00 00 lwz r0,0(r3)
ffc0f5ac: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f5b0: 40 9e 00 14 bne- cr7,ffc0f5c4 <rtems_bdbuf_wake+0x28>
{
sc = rtems_semaphore_flush (waiters->sema);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAKE);
}
}
ffc0f5b4: 80 01 00 0c lwz r0,12(r1)
ffc0f5b8: 38 21 00 08 addi r1,r1,8
ffc0f5bc: 7c 08 03 a6 mtlr r0
ffc0f5c0: 4e 80 00 20 blr
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (waiters->count > 0)
{
sc = rtems_semaphore_flush (waiters->sema);
ffc0f5c4: 80 63 00 04 lwz r3,4(r3)
ffc0f5c8: 48 00 58 8d bl ffc14e54 <rtems_semaphore_flush>
if (sc != RTEMS_SUCCESSFUL)
ffc0f5cc: 2f 83 00 00 cmpwi cr7,r3,0
ffc0f5d0: 41 9e ff e4 beq+ cr7,ffc0f5b4 <rtems_bdbuf_wake+0x18> <== ALWAYS TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAKE);
ffc0f5d4: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0f5d8: 60 63 00 13 ori r3,r3,19 <== NOT EXECUTED
ffc0f5dc: 4b ff b4 d5 bl ffc0aab0 <rtems_fatal_error_occurred> <== NOT EXECUTED
ffc0f2d0 <rtems_bdbuf_wake_swapper>:
}
static void
rtems_bdbuf_wake_swapper (void)
{
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
ffc0f2d0: 3d 20 00 00 lis r9,0
}
}
static void
rtems_bdbuf_wake_swapper (void)
{
ffc0f2d4: 94 21 ff f8 stwu r1,-8(r1)
ffc0f2d8: 7c 08 02 a6 mflr r0
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
ffc0f2dc: 38 80 00 04 li r4,4
ffc0f2e0: 80 69 2a 08 lwz r3,10760(r9)
}
}
static void
rtems_bdbuf_wake_swapper (void)
{
ffc0f2e4: 90 01 00 0c stw r0,12(r1)
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
ffc0f2e8: 4b ff a9 59 bl ffc09c40 <rtems_event_send>
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
ffc0f2ec: 2f 83 00 00 cmpwi cr7,r3,0
ffc0f2f0: 40 9e 00 14 bne- cr7,ffc0f304 <rtems_bdbuf_wake_swapper+0x34><== NEVER TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WAKE);
}
ffc0f2f4: 80 01 00 0c lwz r0,12(r1)
ffc0f2f8: 38 21 00 08 addi r1,r1,8
ffc0f2fc: 7c 08 03 a6 mtlr r0
ffc0f300: 4e 80 00 20 blr
rtems_bdbuf_wake_swapper (void)
{
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WAKE);
ffc0f304: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0f308: 60 63 00 14 ori r3,r3,20 <== NOT EXECUTED
ffc0f30c: 4b ff b7 a5 bl ffc0aab0 <rtems_fatal_error_occurred> <== NOT EXECUTED
ffc11fa0 <rtems_blkdev_generic_ioctl>:
rtems_device_driver
rtems_blkdev_generic_ioctl(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
ffc11fa0: 94 21 ff f0 stwu r1,-16(r1)
ffc11fa4: 7c 08 02 a6 mflr r0
ffc11fa8: 90 01 00 14 stw r0,20(r1)
rtems_libio_ioctl_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
int rc;
switch (args->command)
ffc11fac: 3c 00 40 04 lis r0,16388
ffc11fb0: 60 00 42 03 ori r0,r0,16899
ffc11fb4: 80 85 00 04 lwz r4,4(r5)
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
rtems_libio_ioctl_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
ffc11fb8: 81 25 00 00 lwz r9,0(r5)
int rc;
switch (args->command)
ffc11fbc: 7f 84 00 00 cmpw cr7,r4,r0
rtems_device_driver
rtems_blkdev_generic_ioctl(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
ffc11fc0: 93 e1 00 0c stw r31,12(r1)
ffc11fc4: 7c bf 2b 78 mr r31,r5
rtems_libio_ioctl_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
ffc11fc8: 81 29 00 38 lwz r9,56(r9)
int rc;
switch (args->command)
ffc11fcc: 41 9e 01 40 beq- cr7,ffc1210c <rtems_blkdev_generic_ioctl+0x16c><== NEVER TAKEN
ffc11fd0: 7f 84 00 40 cmplw cr7,r4,r0
ffc11fd4: 40 9d 00 58 ble- cr7,ffc1202c <rtems_blkdev_generic_ioctl+0x8c><== NEVER TAKEN
ffc11fd8: 6c 80 80 04 xoris r0,r4,32772
ffc11fdc: 2f 80 42 04 cmpwi cr7,r0,16900
ffc11fe0: 41 9e 00 b0 beq- cr7,ffc12090 <rtems_blkdev_generic_ioctl+0xf0><== ALWAYS TAKEN
ffc11fe4: 6c 80 c0 18 xoris r0,r4,49176 <== NOT EXECUTED
ffc11fe8: 2f 80 42 01 cmpwi cr7,r0,16897 <== NOT EXECUTED
ffc11fec: 41 9e 00 84 beq- cr7,ffc12070 <rtems_blkdev_generic_ioctl+0xd0><== NOT EXECUTED
ffc11ff0: 6c 80 40 04 xoris r0,r4,16388 <== NOT EXECUTED
ffc11ff4: 2f 80 42 05 cmpwi cr7,r0,16901 <== NOT EXECUTED
ffc11ff8: 41 9e 00 c4 beq- cr7,ffc120bc <rtems_blkdev_generic_ioctl+0x11c><== NOT EXECUTED
*/
args->ioctl_return = (uint32_t) -1;
break;
default:
args->ioctl_return = (uint32_t) dd->ioctl(dd->phys_dev,
ffc11ffc: 80 09 00 28 lwz r0,40(r9) <== NOT EXECUTED
ffc12000: 80 bf 00 08 lwz r5,8(r31) <== NOT EXECUTED
ffc12004: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc12008: 80 69 00 08 lwz r3,8(r9) <== NOT EXECUTED
ffc1200c: 4e 80 04 21 bctrl <== NOT EXECUTED
args->buffer);
break;
}
return RTEMS_SUCCESSFUL;
}
ffc12010: 80 01 00 14 lwz r0,20(r1) <== NOT EXECUTED
*/
args->ioctl_return = (uint32_t) -1;
break;
default:
args->ioctl_return = (uint32_t) dd->ioctl(dd->phys_dev,
ffc12014: 90 7f 00 0c stw r3,12(r31) <== NOT EXECUTED
args->buffer);
break;
}
return RTEMS_SUCCESSFUL;
}
ffc12018: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1201c: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc12020: 83 e1 00 0c lwz r31,12(r1) <== NOT EXECUTED
ffc12024: 38 21 00 10 addi r1,r1,16 <== NOT EXECUTED
ffc12028: 4e 80 00 20 blr <== NOT EXECUTED
rtems_libio_ioctl_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
int rc;
switch (args->command)
ffc1202c: 6c 80 20 00 xoris r0,r4,8192 <== NOT EXECUTED
ffc12030: 2f 80 42 06 cmpwi cr7,r0,16902 <== NOT EXECUTED
ffc12034: 41 9e 00 b4 beq- cr7,ffc120e8 <rtems_blkdev_generic_ioctl+0x148><== NOT EXECUTED
ffc12038: 6c 80 40 04 xoris r0,r4,16388 <== NOT EXECUTED
ffc1203c: 2f 80 42 02 cmpwi cr7,r0,16898 <== NOT EXECUTED
ffc12040: 40 9e ff bc bne+ cr7,ffc11ffc <rtems_blkdev_generic_ioctl+0x5c><== NOT EXECUTED
{
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*((uint32_t *) args->buffer) = dd->media_block_size;
ffc12044: 80 09 00 24 lwz r0,36(r9) <== NOT EXECUTED
args->buffer);
break;
}
return RTEMS_SUCCESSFUL;
}
ffc12048: 38 60 00 00 li r3,0 <== NOT EXECUTED
int rc;
switch (args->command)
{
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*((uint32_t *) args->buffer) = dd->media_block_size;
ffc1204c: 81 25 00 08 lwz r9,8(r5) <== NOT EXECUTED
args->buffer);
break;
}
return RTEMS_SUCCESSFUL;
}
ffc12050: 83 e1 00 0c lwz r31,12(r1) <== NOT EXECUTED
int rc;
switch (args->command)
{
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*((uint32_t *) args->buffer) = dd->media_block_size;
ffc12054: 90 09 00 00 stw r0,0(r9) <== NOT EXECUTED
args->ioctl_return = 0;
ffc12058: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc1205c: 90 05 00 0c stw r0,12(r5) <== NOT EXECUTED
args->buffer);
break;
}
return RTEMS_SUCCESSFUL;
}
ffc12060: 80 01 00 14 lwz r0,20(r1) <== NOT EXECUTED
ffc12064: 38 21 00 10 addi r1,r1,16 <== NOT EXECUTED
ffc12068: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc1206c: 4e 80 00 20 blr <== NOT EXECUTED
case RTEMS_BLKIO_REQUEST:
/*
* It is not allowed to directly access the driver circumventing
* the cache.
*/
args->ioctl_return = (uint32_t) -1;
ffc12070: 38 00 ff ff li r0,-1 <== NOT EXECUTED
ffc12074: 90 1f 00 0c stw r0,12(r31) <== NOT EXECUTED
args->buffer);
break;
}
return RTEMS_SUCCESSFUL;
}
ffc12078: 80 01 00 14 lwz r0,20(r1) <== NOT EXECUTED
ffc1207c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc12080: 83 e1 00 0c lwz r31,12(r1) <== NOT EXECUTED
ffc12084: 38 21 00 10 addi r1,r1,16 <== NOT EXECUTED
ffc12088: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc1208c: 4e 80 00 20 blr <== NOT EXECUTED
*((uint32_t *) args->buffer) = dd->block_size;
args->ioctl_return = 0;
break;
case RTEMS_BLKIO_SETBLKSIZE:
dd->block_size = *((uint32_t *) args->buffer);
ffc12090: 81 65 00 08 lwz r11,8(r5)
args->buffer);
break;
}
return RTEMS_SUCCESSFUL;
}
ffc12094: 38 60 00 00 li r3,0
ffc12098: 83 e1 00 0c lwz r31,12(r1)
*((uint32_t *) args->buffer) = dd->block_size;
args->ioctl_return = 0;
break;
case RTEMS_BLKIO_SETBLKSIZE:
dd->block_size = *((uint32_t *) args->buffer);
ffc1209c: 80 0b 00 00 lwz r0,0(r11)
ffc120a0: 90 09 00 20 stw r0,32(r9)
args->ioctl_return = 0;
ffc120a4: 38 00 00 00 li r0,0
ffc120a8: 90 05 00 0c stw r0,12(r5)
args->buffer);
break;
}
return RTEMS_SUCCESSFUL;
}
ffc120ac: 80 01 00 14 lwz r0,20(r1)
ffc120b0: 38 21 00 10 addi r1,r1,16
ffc120b4: 7c 08 03 a6 mtlr r0
ffc120b8: 4e 80 00 20 blr
dd->block_size = *((uint32_t *) args->buffer);
args->ioctl_return = 0;
break;
case RTEMS_BLKIO_GETSIZE:
*((rtems_blkdev_bnum *) args->buffer) = dd->size;
ffc120bc: 80 09 00 1c lwz r0,28(r9) <== NOT EXECUTED
args->buffer);
break;
}
return RTEMS_SUCCESSFUL;
}
ffc120c0: 38 60 00 00 li r3,0 <== NOT EXECUTED
dd->block_size = *((uint32_t *) args->buffer);
args->ioctl_return = 0;
break;
case RTEMS_BLKIO_GETSIZE:
*((rtems_blkdev_bnum *) args->buffer) = dd->size;
ffc120c4: 81 25 00 08 lwz r9,8(r5) <== NOT EXECUTED
args->buffer);
break;
}
return RTEMS_SUCCESSFUL;
}
ffc120c8: 83 e1 00 0c lwz r31,12(r1) <== NOT EXECUTED
dd->block_size = *((uint32_t *) args->buffer);
args->ioctl_return = 0;
break;
case RTEMS_BLKIO_GETSIZE:
*((rtems_blkdev_bnum *) args->buffer) = dd->size;
ffc120cc: 90 09 00 00 stw r0,0(r9) <== NOT EXECUTED
args->ioctl_return = 0;
ffc120d0: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc120d4: 90 05 00 0c stw r0,12(r5) <== NOT EXECUTED
args->buffer);
break;
}
return RTEMS_SUCCESSFUL;
}
ffc120d8: 80 01 00 14 lwz r0,20(r1) <== NOT EXECUTED
ffc120dc: 38 21 00 10 addi r1,r1,16 <== NOT EXECUTED
ffc120e0: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc120e4: 4e 80 00 20 blr <== NOT EXECUTED
*((rtems_blkdev_bnum *) args->buffer) = dd->size;
args->ioctl_return = 0;
break;
case RTEMS_BLKIO_SYNCDEV:
rc = rtems_bdbuf_syncdev(dd->dev);
ffc120e8: 80 69 00 00 lwz r3,0(r9) <== NOT EXECUTED
ffc120ec: 80 89 00 04 lwz r4,4(r9) <== NOT EXECUTED
ffc120f0: 4b ff fa 75 bl ffc11b64 <rtems_bdbuf_syncdev> <== NOT EXECUTED
args->ioctl_return = (uint32_t) (rc == RTEMS_SUCCESSFUL ? 0 : -1);
ffc120f4: 38 00 ff ff li r0,-1 <== NOT EXECUTED
ffc120f8: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc120fc: 40 9e ff 78 bne+ cr7,ffc12074 <rtems_blkdev_generic_ioctl+0xd4><== NOT EXECUTED
ffc12100: 38 00 00 00 li r0,0 <== NOT EXECUTED
case RTEMS_BLKIO_REQUEST:
/*
* It is not allowed to directly access the driver circumventing
* the cache.
*/
args->ioctl_return = (uint32_t) -1;
ffc12104: 90 1f 00 0c stw r0,12(r31) <== NOT EXECUTED
ffc12108: 4b ff ff 70 b ffc12078 <rtems_blkdev_generic_ioctl+0xd8><== NOT EXECUTED
*((uint32_t *) args->buffer) = dd->media_block_size;
args->ioctl_return = 0;
break;
case RTEMS_BLKIO_GETBLKSIZE:
*((uint32_t *) args->buffer) = dd->block_size;
ffc1210c: 80 09 00 20 lwz r0,32(r9) <== NOT EXECUTED
args->buffer);
break;
}
return RTEMS_SUCCESSFUL;
}
ffc12110: 38 60 00 00 li r3,0 <== NOT EXECUTED
*((uint32_t *) args->buffer) = dd->media_block_size;
args->ioctl_return = 0;
break;
case RTEMS_BLKIO_GETBLKSIZE:
*((uint32_t *) args->buffer) = dd->block_size;
ffc12114: 81 25 00 08 lwz r9,8(r5) <== NOT EXECUTED
args->buffer);
break;
}
return RTEMS_SUCCESSFUL;
}
ffc12118: 83 e1 00 0c lwz r31,12(r1) <== NOT EXECUTED
*((uint32_t *) args->buffer) = dd->media_block_size;
args->ioctl_return = 0;
break;
case RTEMS_BLKIO_GETBLKSIZE:
*((uint32_t *) args->buffer) = dd->block_size;
ffc1211c: 90 09 00 00 stw r0,0(r9) <== NOT EXECUTED
args->ioctl_return = 0;
ffc12120: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc12124: 90 05 00 0c stw r0,12(r5) <== NOT EXECUTED
args->buffer);
break;
}
return RTEMS_SUCCESSFUL;
}
ffc12128: 80 01 00 14 lwz r0,20(r1) <== NOT EXECUTED
ffc1212c: 38 21 00 10 addi r1,r1,16 <== NOT EXECUTED
ffc12130: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc12134: 4e 80 00 20 blr <== NOT EXECUTED
ffc11c70 <rtems_blkdev_generic_read>:
rtems_device_driver
rtems_blkdev_generic_read(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
ffc11c70: 94 21 ff c0 stwu r1,-64(r1)
ffc11c74: 7c 08 02 a6 mflr r0
ffc11c78: 90 01 00 44 stw r0,68(r1)
rtems_status_code rc = RTEMS_SUCCESSFUL;
ffc11c7c: 38 00 00 00 li r0,0
rtems_device_driver
rtems_blkdev_generic_read(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
ffc11c80: 93 61 00 2c stw r27,44(r1)
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
ffc11c84: 83 65 00 14 lwz r27,20(r5)
void * arg)
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
ffc11c88: 81 25 00 00 lwz r9,0(r5)
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
while (count > 0)
ffc11c8c: 2f 9b 00 00 cmpwi cr7,r27,0
rtems_device_driver
rtems_blkdev_generic_read(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
ffc11c90: 92 e1 00 1c stw r23,28(r1)
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
ffc11c94: 81 29 00 38 lwz r9,56(r9)
rtems_device_driver
rtems_blkdev_generic_read(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
ffc11c98: 93 c1 00 38 stw r30,56(r1)
ffc11c9c: 93 e1 00 3c stw r31,60(r1)
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
ffc11ca0: 82 e9 00 20 lwz r23,32(r9)
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
ffc11ca4: 83 c9 00 00 lwz r30,0(r9)
ffc11ca8: 83 e9 00 04 lwz r31,4(r9)
args->bytes_moved = 0;
ffc11cac: 39 20 00 00 li r9,0
rtems_device_driver
rtems_blkdev_generic_read(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
ffc11cb0: 93 01 00 20 stw r24,32(r1)
ffc11cb4: 7c b8 2b 78 mr r24,r5
ffc11cb8: 93 21 00 24 stw r25,36(r1)
ffc11cbc: 93 81 00 30 stw r28,48(r1)
ffc11cc0: 93 a1 00 34 stw r29,52(r1)
ffc11cc4: 93 41 00 28 stw r26,40(r1)
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
ffc11cc8: 83 25 00 10 lwz r25,16(r5)
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
ffc11ccc: 83 85 00 08 lwz r28,8(r5)
ffc11cd0: 83 a5 00 0c lwz r29,12(r5)
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
ffc11cd4: 91 25 00 1c stw r9,28(r5)
while (count > 0)
ffc11cd8: 41 9e 00 b0 beq- cr7,ffc11d88 <rtems_blkdev_generic_read+0x118><== NEVER TAKEN
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
ffc11cdc: 38 a0 00 00 li r5,0
ffc11ce0: 7e e6 bb 78 mr r6,r23
ffc11ce4: 7f 83 e3 78 mr r3,r28
ffc11ce8: 7f a4 eb 78 mr r4,r29
ffc11cec: 48 00 a6 61 bl ffc1c34c <__divdi3>
uint32_t blkofs = (uint32_t) (args->offset % block_size);
ffc11cf0: 7f 83 e3 78 mr r3,r28
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
ffc11cf4: 7c 9a 23 78 mr r26,r4
uint32_t blkofs = (uint32_t) (args->offset % block_size);
ffc11cf8: 38 a0 00 00 li r5,0
ffc11cfc: 7f a4 eb 78 mr r4,r29
ffc11d00: 7e e6 bb 78 mr r6,r23
ffc11d04: 48 00 aa 89 bl ffc1c78c <__moddi3>
ffc11d08: 7c 9c 23 78 mr r28,r4
ffc11d0c: 48 00 00 50 b ffc11d5c <rtems_blkdev_generic_read+0xec>
if (rc != RTEMS_SUCCESSFUL)
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
ffc11d10: 81 21 00 08 lwz r9,8(r1)
uint32_t copy;
rc = rtems_bdbuf_read(dev, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
break;
copy = block_size - blkofs;
ffc11d14: 40 9d 00 08 ble- cr7,ffc11d1c <rtems_blkdev_generic_read+0xac><== ALWAYS TAKEN
ffc11d18: 7f 7d db 78 mr r29,r27 <== NOT EXECUTED
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
ffc11d1c: 80 89 00 24 lwz r4,36(r9)
ffc11d20: 7f a5 eb 78 mr r5,r29
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
while (count > 0)
ffc11d24: 7f 7d d8 50 subf r27,r29,r27
if (rc != RTEMS_SUCCESSFUL)
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
ffc11d28: 7c 84 e2 14 add r4,r4,r28
ffc11d2c: 48 00 74 21 bl ffc1914c <memcpy>
rc = rtems_bdbuf_release(diskbuf);
ffc11d30: 80 61 00 08 lwz r3,8(r1)
args->bytes_moved += copy;
if (rc != RTEMS_SUCCESSFUL)
break;
count -= copy;
buf += copy;
ffc11d34: 7f 39 ea 14 add r25,r25,r29
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
rc = rtems_bdbuf_release(diskbuf);
ffc11d38: 4b ff fa f9 bl ffc11830 <rtems_bdbuf_release>
args->bytes_moved += copy;
ffc11d3c: 81 38 00 1c lwz r9,28(r24)
if (rc != RTEMS_SUCCESSFUL)
ffc11d40: 7c 60 1b 79 mr. r0,r3
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
rc = rtems_bdbuf_release(diskbuf);
args->bytes_moved += copy;
ffc11d44: 7f a9 ea 14 add r29,r9,r29
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
while (count > 0)
ffc11d48: 2f 9b 00 00 cmpwi cr7,r27,0
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
rc = rtems_bdbuf_release(diskbuf);
args->bytes_moved += copy;
ffc11d4c: 93 b8 00 1c stw r29,28(r24)
if (rc != RTEMS_SUCCESSFUL)
ffc11d50: 40 82 00 38 bne- ffc11d88 <rtems_blkdev_generic_read+0x118><== NEVER TAKEN
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
while (count > 0)
ffc11d54: 41 9e 00 34 beq- cr7,ffc11d88 <rtems_blkdev_generic_read+0x118><== ALWAYS TAKEN
args->bytes_moved += copy;
if (rc != RTEMS_SUCCESSFUL)
break;
count -= copy;
buf += copy;
blkofs = 0;
ffc11d58: 3b 80 00 00 li r28,0 <== NOT EXECUTED
while (count > 0)
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
rc = rtems_bdbuf_read(dev, block, &diskbuf);
ffc11d5c: 7f 45 d3 78 mr r5,r26
ffc11d60: 38 c1 00 08 addi r6,r1,8
ffc11d64: 7f c3 f3 78 mr r3,r30
ffc11d68: 7f e4 fb 78 mr r4,r31
ffc11d6c: 4b ff f7 69 bl ffc114d4 <rtems_bdbuf_read>
if (rc != RTEMS_SUCCESSFUL)
break;
copy = block_size - blkofs;
ffc11d70: 7f bc b8 50 subf r29,r28,r23
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
rc = rtems_bdbuf_read(dev, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
ffc11d74: 7c 60 1b 79 mr. r0,r3
break;
copy = block_size - blkofs;
ffc11d78: 7f 9d d8 40 cmplw cr7,r29,r27
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
ffc11d7c: 7f 23 cb 78 mr r3,r25
if (rc != RTEMS_SUCCESSFUL)
break;
count -= copy;
buf += copy;
blkofs = 0;
block++;
ffc11d80: 3b 5a 00 01 addi r26,r26,1
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
rc = rtems_bdbuf_read(dev, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
ffc11d84: 41 82 ff 8c beq+ ffc11d10 <rtems_blkdev_generic_read+0xa0><== ALWAYS TAKEN
blkofs = 0;
block++;
}
return rc;
}
ffc11d88: 7c 03 03 78 mr r3,r0
ffc11d8c: 80 01 00 44 lwz r0,68(r1)
ffc11d90: 82 e1 00 1c lwz r23,28(r1)
ffc11d94: 7c 08 03 a6 mtlr r0
ffc11d98: 83 01 00 20 lwz r24,32(r1)
ffc11d9c: 83 21 00 24 lwz r25,36(r1)
ffc11da0: 83 41 00 28 lwz r26,40(r1)
ffc11da4: 83 61 00 2c lwz r27,44(r1)
ffc11da8: 83 81 00 30 lwz r28,48(r1)
ffc11dac: 83 a1 00 34 lwz r29,52(r1)
ffc11db0: 83 c1 00 38 lwz r30,56(r1)
ffc11db4: 83 e1 00 3c lwz r31,60(r1)
ffc11db8: 38 21 00 40 addi r1,r1,64
ffc11dbc: 4e 80 00 20 blr
ffc11dc0 <rtems_blkdev_generic_write>:
rtems_device_driver
rtems_blkdev_generic_write(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
ffc11dc0: 94 21 ff c0 stwu r1,-64(r1)
ffc11dc4: 7c 08 02 a6 mflr r0
rtems_status_code rc = RTEMS_SUCCESSFUL;
ffc11dc8: 38 60 00 00 li r3,0
rtems_device_driver
rtems_blkdev_generic_write(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
ffc11dcc: 90 01 00 44 stw r0,68(r1)
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
ffc11dd0: 38 00 00 00 li r0,0
rtems_device_driver
rtems_blkdev_generic_write(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
ffc11dd4: 93 61 00 2c stw r27,44(r1)
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
ffc11dd8: 83 65 00 14 lwz r27,20(r5)
void * arg)
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
ffc11ddc: 81 25 00 00 lwz r9,0(r5)
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
while (count > 0)
ffc11de0: 2f 9b 00 00 cmpwi cr7,r27,0
rtems_device_driver
rtems_blkdev_generic_write(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
ffc11de4: 92 e1 00 1c stw r23,28(r1)
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
ffc11de8: 81 29 00 38 lwz r9,56(r9)
rtems_device_driver
rtems_blkdev_generic_write(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
ffc11dec: 93 01 00 20 stw r24,32(r1)
ffc11df0: 7c b8 2b 78 mr r24,r5
ffc11df4: 93 21 00 24 stw r25,36(r1)
ffc11df8: 93 81 00 30 stw r28,48(r1)
ffc11dfc: 93 a1 00 34 stw r29,52(r1)
ffc11e00: 93 c1 00 38 stw r30,56(r1)
ffc11e04: 93 e1 00 3c stw r31,60(r1)
ffc11e08: 92 c1 00 18 stw r22,24(r1)
ffc11e0c: 93 41 00 28 stw r26,40(r1)
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
ffc11e10: 82 e9 00 20 lwz r23,32(r9)
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
ffc11e14: 83 c9 00 00 lwz r30,0(r9)
ffc11e18: 83 e9 00 04 lwz r31,4(r9)
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
ffc11e1c: 83 25 00 10 lwz r25,16(r5)
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
ffc11e20: 83 85 00 08 lwz r28,8(r5)
ffc11e24: 83 a5 00 0c lwz r29,12(r5)
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
ffc11e28: 90 05 00 1c stw r0,28(r5)
while (count > 0)
ffc11e2c: 41 9e 00 d4 beq- cr7,ffc11f00 <rtems_blkdev_generic_write+0x140><== NEVER TAKEN
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
ffc11e30: 38 a0 00 00 li r5,0
ffc11e34: 7e e6 bb 78 mr r6,r23
ffc11e38: 7f 83 e3 78 mr r3,r28
ffc11e3c: 7f a4 eb 78 mr r4,r29
ffc11e40: 48 00 a5 0d bl ffc1c34c <__divdi3>
uint32_t blkofs = (uint32_t) (args->offset % block_size);
ffc11e44: 7f 83 e3 78 mr r3,r28
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
ffc11e48: 7c 9a 23 78 mr r26,r4
uint32_t blkofs = (uint32_t) (args->offset % block_size);
ffc11e4c: 38 a0 00 00 li r5,0
ffc11e50: 7f a4 eb 78 mr r4,r29
ffc11e54: 7e e6 bb 78 mr r6,r23
ffc11e58: 48 00 a9 35 bl ffc1c78c <__moddi3>
ffc11e5c: 3b a1 00 08 addi r29,r1,8
while (count > 0)
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
ffc11e60: 7c 9c 23 79 mr. r28,r4
ffc11e64: 41 a2 00 78 beq+ ffc11edc <rtems_blkdev_generic_write+0x11c><== ALWAYS TAKEN
rc = rtems_bdbuf_get(dev, block, &diskbuf);
else
rc = rtems_bdbuf_read(dev, block, &diskbuf);
ffc11e68: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc11e6c: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc11e70: 7f 45 d3 78 mr r5,r26 <== NOT EXECUTED
ffc11e74: 7f a6 eb 78 mr r6,r29 <== NOT EXECUTED
ffc11e78: 4b ff f6 5d bl ffc114d4 <rtems_bdbuf_read> <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
ffc11e7c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc11e80: 40 9e 00 80 bne- cr7,ffc11f00 <rtems_blkdev_generic_write+0x140><== NOT EXECUTED
break;
copy = block_size - blkofs;
ffc11e84: 7e dc b8 50 subf r22,r28,r23
ffc11e88: 7f 96 d8 40 cmplw cr7,r22,r27
ffc11e8c: 40 9d 00 08 ble- cr7,ffc11e94 <rtems_blkdev_generic_write+0xd4><== ALWAYS TAKEN
ffc11e90: 7f 76 db 78 mr r22,r27 <== NOT EXECUTED
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
ffc11e94: 81 21 00 08 lwz r9,8(r1)
ffc11e98: 7f 24 cb 78 mr r4,r25
ffc11e9c: 7e c5 b3 78 mr r5,r22
ffc11ea0: 80 69 00 24 lwz r3,36(r9)
ffc11ea4: 7c 63 e2 14 add r3,r3,r28
ffc11ea8: 48 00 72 a5 bl ffc1914c <memcpy>
args->bytes_moved += copy;
ffc11eac: 80 18 00 1c lwz r0,28(r24)
rc = rtems_bdbuf_release_modified(diskbuf);
ffc11eb0: 80 61 00 08 lwz r3,8(r1)
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
args->bytes_moved += copy;
ffc11eb4: 7c 00 b2 14 add r0,r0,r22
ffc11eb8: 90 18 00 1c stw r0,28(r24)
rc = rtems_bdbuf_release_modified(diskbuf);
ffc11ebc: 4b ff fa 7d bl ffc11938 <rtems_bdbuf_release_modified>
if (rc != RTEMS_SUCCESSFUL)
ffc11ec0: 2c 03 00 00 cmpwi r3,0
ffc11ec4: 40 82 00 3c bne- ffc11f00 <rtems_blkdev_generic_write+0x140><== NEVER TAKEN
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
while (count > 0)
ffc11ec8: 7f 76 d8 51 subf. r27,r22,r27
rc = rtems_bdbuf_release_modified(diskbuf);
if (rc != RTEMS_SUCCESSFUL)
break;
count -= copy;
buf += copy;
ffc11ecc: 7f 39 b2 14 add r25,r25,r22
blkofs = 0;
block++;
ffc11ed0: 3b 5a 00 01 addi r26,r26,1
if (rc != RTEMS_SUCCESSFUL)
break;
count -= copy;
buf += copy;
blkofs = 0;
ffc11ed4: 3b 80 00 00 li r28,0
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
while (count > 0)
ffc11ed8: 41 82 00 28 beq- ffc11f00 <rtems_blkdev_generic_write+0x140><== ALWAYS TAKEN
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
ffc11edc: 7f 97 d8 40 cmplw cr7,r23,r27
ffc11ee0: 41 9d ff 88 bgt+ cr7,ffc11e68 <rtems_blkdev_generic_write+0xa8><== NEVER TAKEN
rc = rtems_bdbuf_get(dev, block, &diskbuf);
ffc11ee4: 7f c3 f3 78 mr r3,r30
ffc11ee8: 7f e4 fb 78 mr r4,r31
ffc11eec: 7f 45 d3 78 mr r5,r26
ffc11ef0: 7f a6 eb 78 mr r6,r29
ffc11ef4: 4b ff f4 bd bl ffc113b0 <rtems_bdbuf_get>
else
rc = rtems_bdbuf_read(dev, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
ffc11ef8: 2f 83 00 00 cmpwi cr7,r3,0
ffc11efc: 41 9e ff 88 beq+ cr7,ffc11e84 <rtems_blkdev_generic_write+0xc4><== ALWAYS TAKEN
blkofs = 0;
block++;
}
return rc;
}
ffc11f00: 80 01 00 44 lwz r0,68(r1)
ffc11f04: 82 c1 00 18 lwz r22,24(r1)
ffc11f08: 7c 08 03 a6 mtlr r0
ffc11f0c: 82 e1 00 1c lwz r23,28(r1)
ffc11f10: 83 01 00 20 lwz r24,32(r1)
ffc11f14: 83 21 00 24 lwz r25,36(r1)
ffc11f18: 83 41 00 28 lwz r26,40(r1)
ffc11f1c: 83 61 00 2c lwz r27,44(r1)
ffc11f20: 83 81 00 30 lwz r28,48(r1)
ffc11f24: 83 a1 00 34 lwz r29,52(r1)
ffc11f28: 83 c1 00 38 lwz r30,56(r1)
ffc11f2c: 83 e1 00 3c lwz r31,60(r1)
ffc11f30: 38 21 00 40 addi r1,r1,64
ffc11f34: 4e 80 00 20 blr
ffc12138 <rtems_blkdev_ioctl>:
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
ffc12138: 7c 08 02 a6 mflr r0
ffc1213c: 94 21 ff f8 stwu r1,-8(r1)
ffc12140: 7c 69 1b 78 mr r9,r3
ffc12144: 90 01 00 0c stw r0,12(r1)
size_t *arg_size = argp;
int rc = 0;
switch (req)
ffc12148: 3c 00 40 04 lis r0,16388
ffc1214c: 60 00 42 03 ori r0,r0,16899
ffc12150: 7f 84 00 00 cmpw cr7,r4,r0
ffc12154: 41 9e 00 8c beq- cr7,ffc121e0 <rtems_blkdev_ioctl+0xa8> <== NEVER TAKEN
ffc12158: 7f 84 00 40 cmplw cr7,r4,r0
ffc1215c: 3c 00 40 04 lis r0,16388
ffc12160: 41 9d 00 30 bgt- cr7,ffc12190 <rtems_blkdev_ioctl+0x58>
ffc12164: 60 00 42 02 ori r0,r0,16898
ffc12168: 7f 84 00 00 cmpw cr7,r4,r0
ffc1216c: 41 9e 00 90 beq- cr7,ffc121fc <rtems_blkdev_ioctl+0xc4> <== NEVER TAKEN
case RTEMS_BLKIO_GETSIZE:
*arg_size = dd->size;
break;
default:
errno = EINVAL;
ffc12170: 48 00 63 b1 bl ffc18520 <__errno>
ffc12174: 38 00 00 16 li r0,22
ffc12178: 90 03 00 00 stw r0,0(r3)
rc = -1;
ffc1217c: 38 60 ff ff li r3,-1
break;
}
return rc;
}
ffc12180: 80 01 00 0c lwz r0,12(r1)
ffc12184: 38 21 00 08 addi r1,r1,8
ffc12188: 7c 08 03 a6 mtlr r0
ffc1218c: 4e 80 00 20 blr
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
size_t *arg_size = argp;
int rc = 0;
switch (req)
ffc12190: 60 00 42 05 ori r0,r0,16901
ffc12194: 7f 84 00 00 cmpw cr7,r4,r0
ffc12198: 41 9e 00 2c beq- cr7,ffc121c4 <rtems_blkdev_ioctl+0x8c> <== NEVER TAKEN
ffc1219c: 6c 80 80 04 xoris r0,r4,32772
ffc121a0: 2f 80 42 04 cmpwi cr7,r0,16900
ffc121a4: 40 9e ff cc bne+ cr7,ffc12170 <rtems_blkdev_ioctl+0x38> <== NEVER TAKEN
case RTEMS_BLKIO_GETBLKSIZE:
*arg_size = dd->block_size;
break;
case RTEMS_BLKIO_SETBLKSIZE:
dd->block_size = *arg_size;
ffc121a8: 80 05 00 00 lwz r0,0(r5)
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
size_t *arg_size = argp;
int rc = 0;
ffc121ac: 38 60 00 00 li r3,0
case RTEMS_BLKIO_GETBLKSIZE:
*arg_size = dd->block_size;
break;
case RTEMS_BLKIO_SETBLKSIZE:
dd->block_size = *arg_size;
ffc121b0: 90 09 00 20 stw r0,32(r9)
rc = -1;
break;
}
return rc;
}
ffc121b4: 80 01 00 0c lwz r0,12(r1)
ffc121b8: 38 21 00 08 addi r1,r1,8
ffc121bc: 7c 08 03 a6 mtlr r0
ffc121c0: 4e 80 00 20 blr
case RTEMS_BLKIO_SETBLKSIZE:
dd->block_size = *arg_size;
break;
case RTEMS_BLKIO_GETSIZE:
*arg_size = dd->size;
ffc121c4: 80 03 00 1c lwz r0,28(r3) <== NOT EXECUTED
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
size_t *arg_size = argp;
int rc = 0;
ffc121c8: 38 60 00 00 li r3,0 <== NOT EXECUTED
case RTEMS_BLKIO_SETBLKSIZE:
dd->block_size = *arg_size;
break;
case RTEMS_BLKIO_GETSIZE:
*arg_size = dd->size;
ffc121cc: 90 05 00 00 stw r0,0(r5) <== NOT EXECUTED
rc = -1;
break;
}
return rc;
}
ffc121d0: 80 01 00 0c lwz r0,12(r1) <== NOT EXECUTED
ffc121d4: 38 21 00 08 addi r1,r1,8 <== NOT EXECUTED
ffc121d8: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc121dc: 4e 80 00 20 blr <== NOT EXECUTED
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*arg_size = dd->media_block_size;
break;
case RTEMS_BLKIO_GETBLKSIZE:
*arg_size = dd->block_size;
ffc121e0: 80 03 00 20 lwz r0,32(r3) <== NOT EXECUTED
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
size_t *arg_size = argp;
int rc = 0;
ffc121e4: 38 60 00 00 li r3,0 <== NOT EXECUTED
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*arg_size = dd->media_block_size;
break;
case RTEMS_BLKIO_GETBLKSIZE:
*arg_size = dd->block_size;
ffc121e8: 90 05 00 00 stw r0,0(r5) <== NOT EXECUTED
rc = -1;
break;
}
return rc;
}
ffc121ec: 80 01 00 0c lwz r0,12(r1) <== NOT EXECUTED
ffc121f0: 38 21 00 08 addi r1,r1,8 <== NOT EXECUTED
ffc121f4: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc121f8: 4e 80 00 20 blr <== NOT EXECUTED
int rc = 0;
switch (req)
{
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*arg_size = dd->media_block_size;
ffc121fc: 80 03 00 24 lwz r0,36(r3) <== NOT EXECUTED
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
size_t *arg_size = argp;
int rc = 0;
ffc12200: 38 60 00 00 li r3,0 <== NOT EXECUTED
switch (req)
{
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*arg_size = dd->media_block_size;
ffc12204: 90 05 00 00 stw r0,0(r5) <== NOT EXECUTED
rc = -1;
break;
}
return rc;
}
ffc12208: 80 01 00 0c lwz r0,12(r1) <== NOT EXECUTED
ffc1220c: 38 21 00 08 addi r1,r1,8 <== NOT EXECUTED
ffc12210: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc12214: 4e 80 00 20 blr <== NOT EXECUTED
ffc041b0 <rtems_bsp_cmdline_get_param>:
size_t length
)
{
const char *p;
if ( !name )
ffc041b0: 2f 83 00 00 cmpwi cr7,r3,0
const char *rtems_bsp_cmdline_get_param(
const char *name,
char *value,
size_t length
)
{
ffc041b4: 94 21 ff f0 stwu r1,-16(r1)
ffc041b8: 7c 08 02 a6 mflr r0
ffc041bc: 93 c1 00 08 stw r30,8(r1)
ffc041c0: 7c be 2b 78 mr r30,r5
ffc041c4: 93 e1 00 0c stw r31,12(r1)
ffc041c8: 7c 9f 23 78 mr r31,r4
ffc041cc: 90 01 00 14 stw r0,20(r1)
const char *p;
if ( !name )
ffc041d0: 41 9e 00 c8 beq- cr7,ffc04298 <rtems_bsp_cmdline_get_param+0xe8>
return NULL;
if ( !value )
ffc041d4: 2f 84 00 00 cmpwi cr7,r4,0
ffc041d8: 41 9e 00 a4 beq- cr7,ffc0427c <rtems_bsp_cmdline_get_param+0xcc>
return NULL;
if ( !length )
ffc041dc: 2f 85 00 00 cmpwi cr7,r5,0
ffc041e0: 41 9e 00 b8 beq- cr7,ffc04298 <rtems_bsp_cmdline_get_param+0xe8>
return NULL;
value[0] = '\0';
ffc041e4: 38 00 00 00 li r0,0
ffc041e8: 98 04 00 00 stb r0,0(r4)
p = rtems_bsp_cmdline_get_param_raw( name );
ffc041ec: 48 00 00 cd bl ffc042b8 <rtems_bsp_cmdline_get_param_raw>
if ( !p )
ffc041f0: 2c 03 00 00 cmpwi r3,0
ffc041f4: 41 82 00 a4 beq- ffc04298 <rtems_bsp_cmdline_get_param+0xe8>
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
ffc041f8: 88 03 00 00 lbz r0,0(r3)
ffc041fc: 2f 80 00 00 cmpwi cr7,r0,0
ffc04200: 41 9e 00 7c beq- cr7,ffc0427c <rtems_bsp_cmdline_get_param+0xcc><== NEVER TAKEN
ffc04204: 34 fe ff ff addic. r7,r30,-1
ffc04208: 7c e9 03 a6 mtctr r7
ffc0420c: 41 82 00 70 beq- ffc0427c <rtems_bsp_cmdline_get_param+0xcc><== NEVER TAKEN
ffc04210: 39 60 00 00 li r11,0
value[i] = '\0';
}
}
const char *rtems_bsp_cmdline_get_param(
ffc04214: 39 20 00 00 li r9,0
ffc04218: 39 40 00 00 li r10,0
if ( *p == '\"' ) {
quotes++;
} else if ( ((quotes % 2) == 0) && *p == ' ' )
break;
value[i++] = *p++;
value[i] = '\0';
ffc0421c: 39 00 00 00 li r8,0
ffc04220: 48 00 00 30 b ffc04250 <rtems_bsp_cmdline_get_param+0xa0>
quotes=0;
for (i=0 ; *p && i<length-1; ) {
if ( *p == '\"' ) {
quotes++;
} else if ( ((quotes % 2) == 0) && *p == ' ' )
ffc04224: 2f 80 00 20 cmpwi cr7,r0,32
ffc04228: 40 82 00 08 bne- ffc04230 <rtems_bsp_cmdline_get_param+0x80>
ffc0422c: 41 9e 00 50 beq- cr7,ffc0427c <rtems_bsp_cmdline_get_param+0xcc>
break;
value[i++] = *p++;
ffc04230: 39 29 00 01 addi r9,r9,1
ffc04234: 7c 1f 59 ae stbx r0,r31,r11
value[i] = '\0';
ffc04238: 7d 2b 4b 78 mr r11,r9
ffc0423c: 7d 1f 49 ae stbx r8,r31,r9
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
ffc04240: 8c 03 00 01 lbzu r0,1(r3)
ffc04244: 2f 80 00 00 cmpwi cr7,r0,0
ffc04248: 41 9e 00 34 beq- cr7,ffc0427c <rtems_bsp_cmdline_get_param+0xcc>
ffc0424c: 42 40 00 30 bdz- ffc0427c <rtems_bsp_cmdline_get_param+0xcc>
if ( *p == '\"' ) {
ffc04250: 2f 80 00 22 cmpwi cr7,r0,34
quotes++;
} else if ( ((quotes % 2) == 0) && *p == ' ' )
ffc04254: 71 47 00 01 andi. r7,r10,1
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
if ( *p == '\"' ) {
ffc04258: 40 9e ff cc bne+ cr7,ffc04224 <rtems_bsp_cmdline_get_param+0x74>
quotes++;
} else if ( ((quotes % 2) == 0) && *p == ' ' )
break;
value[i++] = *p++;
ffc0425c: 39 29 00 01 addi r9,r9,1
ffc04260: 7c 1f 59 ae stbx r0,r31,r11
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
if ( *p == '\"' ) {
quotes++;
ffc04264: 39 4a 00 01 addi r10,r10,1
} else if ( ((quotes % 2) == 0) && *p == ' ' )
break;
value[i++] = *p++;
value[i] = '\0';
ffc04268: 7d 1f 49 ae stbx r8,r31,r9
ffc0426c: 7d 2b 4b 78 mr r11,r9
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
ffc04270: 8c 03 00 01 lbzu r0,1(r3)
ffc04274: 2f 80 00 00 cmpwi cr7,r0,0
ffc04278: 40 9e ff d4 bne+ cr7,ffc0424c <rtems_bsp_cmdline_get_param+0x9c><== ALWAYS TAKEN
return NULL;
copy_string( p, value, length );
return value;
}
ffc0427c: 80 01 00 14 lwz r0,20(r1)
ffc04280: 7f e3 fb 78 mr r3,r31
ffc04284: 83 c1 00 08 lwz r30,8(r1)
ffc04288: 7c 08 03 a6 mtlr r0
ffc0428c: 83 e1 00 0c lwz r31,12(r1)
ffc04290: 38 21 00 10 addi r1,r1,16
ffc04294: 4e 80 00 20 blr
ffc04298: 80 01 00 14 lwz r0,20(r1)
value[0] = '\0';
p = rtems_bsp_cmdline_get_param_raw( name );
if ( !p )
return NULL;
ffc0429c: 3b e0 00 00 li r31,0
copy_string( p, value, length );
return value;
}
ffc042a0: 7f e3 fb 78 mr r3,r31
ffc042a4: 83 c1 00 08 lwz r30,8(r1)
ffc042a8: 7c 08 03 a6 mtlr r0
ffc042ac: 83 e1 00 0c lwz r31,12(r1)
ffc042b0: 38 21 00 10 addi r1,r1,16
ffc042b4: 4e 80 00 20 blr
ffc09e40 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
ffc09e40: 94 21 ff d0 stwu r1,-48(r1)
ffc09e44: 7c 08 02 a6 mflr r0
ffc09e48: 93 e1 00 2c stw r31,44(r1)
ffc09e4c: 90 01 00 34 stw r0,52(r1)
ffc09e50: 93 61 00 1c stw r27,28(r1)
ffc09e54: 7c db 33 78 mr r27,r6
ffc09e58: 93 81 00 20 stw r28,32(r1)
ffc09e5c: 7c 7c 1b 78 mr r28,r3
ffc09e60: 93 a1 00 24 stw r29,36(r1)
ffc09e64: 7c 9d 23 78 mr r29,r4
ffc09e68: 93 c1 00 28 stw r30,40(r1)
ffc09e6c: 7c be 2b 78 mr r30,r5
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
ffc09e70: 7f 83 e3 78 mr r3,r28
ffc09e74: 48 00 07 e5 bl ffc0a658 <_Chain_Get>
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
ffc09e78: 38 80 00 00 li r4,0
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
ffc09e7c: 7c 7f 1b 79 mr. r31,r3
) {
rtems_event_set out;
sc = rtems_event_receive(
ffc09e80: 7f c5 f3 78 mr r5,r30
ffc09e84: 38 c1 00 08 addi r6,r1,8
ffc09e88: 7f a3 eb 78 mr r3,r29
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
ffc09e8c: 40 82 00 38 bne- ffc09ec4 <rtems_chain_get_with_wait+0x84>
) {
rtems_event_set out;
sc = rtems_event_receive(
ffc09e90: 4b ff ef f9 bl ffc08e88 <rtems_event_receive>
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
ffc09e94: 2c 03 00 00 cmpwi r3,0
ffc09e98: 41 82 ff d8 beq+ ffc09e70 <rtems_chain_get_with_wait+0x30><== NEVER TAKEN
}
*node_ptr = node;
return sc;
}
ffc09e9c: 80 01 00 34 lwz r0,52(r1)
timeout,
&out
);
}
*node_ptr = node;
ffc09ea0: 93 fb 00 00 stw r31,0(r27)
return sc;
}
ffc09ea4: 7c 08 03 a6 mtlr r0
ffc09ea8: 83 61 00 1c lwz r27,28(r1)
ffc09eac: 83 81 00 20 lwz r28,32(r1)
ffc09eb0: 83 a1 00 24 lwz r29,36(r1)
ffc09eb4: 83 c1 00 28 lwz r30,40(r1)
ffc09eb8: 83 e1 00 2c lwz r31,44(r1)
ffc09ebc: 38 21 00 30 addi r1,r1,48
ffc09ec0: 4e 80 00 20 blr
ffc09ec4: 80 01 00 34 lwz r0,52(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
ffc09ec8: 38 60 00 00 li r3,0
timeout,
&out
);
}
*node_ptr = node;
ffc09ecc: 93 fb 00 00 stw r31,0(r27)
return sc;
}
ffc09ed0: 7c 08 03 a6 mtlr r0
ffc09ed4: 83 61 00 1c lwz r27,28(r1)
ffc09ed8: 83 81 00 20 lwz r28,32(r1)
ffc09edc: 83 a1 00 24 lwz r29,36(r1)
ffc09ee0: 83 c1 00 28 lwz r30,40(r1)
ffc09ee4: 83 e1 00 2c lwz r31,44(r1)
ffc09ee8: 38 21 00 30 addi r1,r1,48
ffc09eec: 4e 80 00 20 blr
ffc05138 <rtems_cpu_usage_report_with_plugin>:
*/
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
ffc05138: 94 21 ff 70 stwu r1,-144(r1)
ffc0513c: 7c 08 02 a6 mflr r0
ffc05140: 90 01 00 94 stw r0,148(r1)
Timestamp_Control uptime, total, ran, uptime_at_last_reset;
#else
uint32_t total_units = 0;
#endif
if ( !print )
ffc05144: 7c 80 23 79 mr. r0,r4
*/
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
ffc05148: 93 a1 00 84 stw r29,132(r1)
ffc0514c: 7c 7d 1b 78 mr r29,r3
ffc05150: 92 a1 00 64 stw r21,100(r1)
ffc05154: 92 c1 00 68 stw r22,104(r1)
ffc05158: 92 e1 00 6c stw r23,108(r1)
ffc0515c: 93 01 00 70 stw r24,112(r1)
ffc05160: 93 21 00 74 stw r25,116(r1)
ffc05164: 93 41 00 78 stw r26,120(r1)
ffc05168: 93 61 00 7c stw r27,124(r1)
ffc0516c: 93 81 00 80 stw r28,128(r1)
ffc05170: 93 c1 00 88 stw r30,136(r1)
ffc05174: 93 e1 00 8c stw r31,140(r1)
Timestamp_Control uptime, total, ran, uptime_at_last_reset;
#else
uint32_t total_units = 0;
#endif
if ( !print )
ffc05178: 90 01 00 58 stw r0,88(r1)
ffc0517c: 41 82 01 e0 beq- ffc0535c <rtems_cpu_usage_report_with_plugin+0x224><== 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;
ffc05180: 3d 20 00 00 lis r9,0
ffc05184: 39 29 28 d8 addi r9,r9,10456
* 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 );
ffc05188: 38 00 00 00 li r0,0
uptime_at_last_reset = CPU_usage_Uptime_at_last_reset;
ffc0518c: 81 49 00 00 lwz r10,0(r9)
ffc05190: 81 69 00 04 lwz r11,4(r9)
}
}
}
#endif
(*print)(
ffc05194: 3c 80 ff c2 lis r4,-62
* 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 );
ffc05198: 90 01 00 30 stw r0,48(r1)
}
}
}
#endif
(*print)(
ffc0519c: 38 84 2e 50 addi r4,r4,11856
ffc051a0: 3f 00 00 00 lis r24,0
* 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 );
ffc051a4: 90 01 00 34 stw r0,52(r1)
}
}
}
#endif
(*print)(
ffc051a8: 3b 18 30 80 addi r24,r24,12416
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
(*print)(
ffc051ac: 3f 40 ff c2 lis r26,-62
}
}
}
#endif
(*print)(
ffc051b0: 80 01 00 58 lwz r0,88(r1)
/*
* Print the information
*/
(*print)( context,
ffc051b4: 3f 60 ff c2 lis r27,-62
* 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;
ffc051b8: 91 41 00 20 stw r10,32(r1)
/*
* Print the information
*/
(*print)( context,
ffc051bc: 3f 80 10 62 lis r28,4194
}
}
}
#endif
(*print)(
ffc051c0: 7c 09 03 a6 mtctr r0
Thread_Control *the_thread,
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
ffc051c4: 3f 20 00 00 lis r25,0
* 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;
ffc051c8: 91 61 00 24 stw r11,36(r1)
#endif
/*
* rtems_cpu_usage_report
*/
void rtems_cpu_usage_report_with_plugin(
ffc051cc: 3a f8 00 0c addi r23,r24,12
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
(*print)(
ffc051d0: 3b 5a 2f c4 addi r26,r26,12228
/*
* Print the information
*/
(*print)( context,
ffc051d4: 3b 7b 2f d8 addi r27,r27,12248
ffc051d8: 63 9c 4d d3 ori r28,r28,19923
}
}
}
#endif
(*print)(
ffc051dc: 4c c6 31 82 crclr 4*cr1+eq
ffc051e0: 4e 80 04 21 bctrl
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
ffc051e4: 85 38 00 04 lwzu r9,4(r24)
ffc051e8: 83 c9 00 04 lwz r30,4(r9)
if ( information ) {
ffc051ec: 2f 9e 00 00 cmpwi cr7,r30,0
ffc051f0: 41 9e 01 30 beq- cr7,ffc05320 <rtems_cpu_usage_report_with_plugin+0x1e8><== NEVER TAKEN
for ( i=1 ; i <= information->maximum ; i++ ) {
ffc051f4: a1 7e 00 10 lhz r11,16(r30)
ffc051f8: 71 60 ff ff andi. r0,r11,65535
ffc051fc: 41 82 01 24 beq- ffc05320 <rtems_cpu_usage_report_with_plugin+0x1e8>
ffc05200: 3b e0 00 01 li r31,1
ffc05204: 48 00 00 70 b ffc05274 <rtems_cpu_usage_report_with_plugin+0x13c>
Timestamp_Control used;
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract( &last, &uptime, &used );
_Timestamp_Add_to( &ran, &used );
} else {
_TOD_Get_uptime( &uptime );
ffc05208: 48 00 6f e5 bl ffc0c1ec <_TOD_Get_uptime>
}
_Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
ffc0520c: 38 61 00 20 addi r3,r1,32
ffc05210: 38 81 00 38 addi r4,r1,56
ffc05214: 38 a1 00 30 addi r5,r1,48
ffc05218: 48 00 9f 0d bl ffc0f124 <_Timespec_Subtract>
_Timestamp_Divide( &ran, &total, &ival, &fval );
ffc0521c: 7e a3 ab 78 mr r3,r21
ffc05220: 38 81 00 30 addi r4,r1,48
ffc05224: 38 a1 00 0c addi r5,r1,12
ffc05228: 38 c1 00 08 addi r6,r1,8
ffc0522c: 48 00 9d ed bl ffc0f018 <_Timespec_Divide>
/*
* Print the information
*/
(*print)( context,
ffc05230: 80 c1 00 2c lwz r6,44(r1)
ffc05234: 80 01 00 58 lwz r0,88(r1)
ffc05238: 7f a3 eb 78 mr r3,r29
ffc0523c: 7c c6 e0 16 mulhwu r6,r6,r28
ffc05240: 80 a1 00 28 lwz r5,40(r1)
ffc05244: 80 e1 00 0c lwz r7,12(r1)
ffc05248: 7c 09 03 a6 mtctr r0
ffc0524c: 7f 64 db 78 mr r4,r27
ffc05250: 81 01 00 08 lwz r8,8(r1)
ffc05254: 54 c6 d1 be rlwinm r6,r6,26,6,31
ffc05258: 4c c6 31 82 crclr 4*cr1+eq
ffc0525c: 4e 80 04 21 bctrl
ffc05260: a1 7e 00 10 lhz r11,16(r30)
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
ffc05264: 3b ff 00 01 addi r31,r31,1
ffc05268: 55 60 04 3e clrlwi r0,r11,16
ffc0526c: 7f 80 f8 40 cmplw cr7,r0,r31
ffc05270: 41 9c 00 b0 blt- cr7,ffc05320 <rtems_cpu_usage_report_with_plugin+0x1e8>
the_thread = (Thread_Control *)information->local_table[ i ];
ffc05274: 81 3e 00 1c lwz r9,28(r30)
ffc05278: 57 e0 10 3a rlwinm r0,r31,2,0,29
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
ffc0527c: 38 a1 00 40 addi r5,r1,64
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
ffc05280: 7e c9 00 2e lwzx r22,r9,r0
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
ffc05284: 38 80 00 0d li r4,13
ffc05288: 3a a1 00 28 addi r21,r1,40
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
if ( !the_thread )
ffc0528c: 2f 96 00 00 cmpwi cr7,r22,0
ffc05290: 41 be ff d4 beq- cr7,ffc05264 <rtems_cpu_usage_report_with_plugin+0x12c><== NEVER TAKEN
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
ffc05294: 80 76 00 08 lwz r3,8(r22)
ffc05298: 48 00 54 45 bl ffc0a6dc <rtems_object_get_name>
(*print)(
ffc0529c: 80 01 00 58 lwz r0,88(r1)
ffc052a0: 7f a3 eb 78 mr r3,r29
ffc052a4: 80 b6 00 08 lwz r5,8(r22)
ffc052a8: 7c 09 03 a6 mtctr r0
ffc052ac: 7f 44 d3 78 mr r4,r26
ffc052b0: 38 c1 00 40 addi r6,r1,64
ffc052b4: 4c c6 31 82 crclr 4*cr1+eq
ffc052b8: 4e 80 04 21 bctrl
Thread_Control *the_thread,
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
ffc052bc: 39 39 35 a4 addi r9,r25,13732
ffc052c0: 81 69 00 0c lwz r11,12(r9)
Timestamp_Control used;
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract( &last, &uptime, &used );
_Timestamp_Add_to( &ran, &used );
} else {
_TOD_Get_uptime( &uptime );
ffc052c4: 38 61 00 38 addi r3,r1,56
Thread_Control *the_thread,
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
ffc052c8: 81 16 00 08 lwz r8,8(r22)
ffc052cc: 80 0b 00 08 lwz r0,8(r11)
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
ffc052d0: 81 56 00 84 lwz r10,132(r22)
Thread_Control *the_thread,
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
ffc052d4: 7f 88 00 00 cmpw cr7,r8,r0
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
ffc052d8: 81 76 00 88 lwz r11,136(r22)
ffc052dc: 91 41 00 28 stw r10,40(r1)
ffc052e0: 91 61 00 2c stw r11,44(r1)
Thread_Control *the_thread,
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
ffc052e4: 40 9e ff 24 bne+ cr7,ffc05208 <rtems_cpu_usage_report_with_plugin+0xd0>
*time_of_context_switch = _Thread_Time_of_last_context_switch;
ffc052e8: 81 49 00 1c lwz r10,28(r9)
ran = the_thread->cpu_time_used;
if ( is_executing_on_a_core( the_thread, &last ) ) {
Timestamp_Control used;
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract( &last, &uptime, &used );
_Timestamp_Add_to( &ran, &used );
ffc052ec: 3a a1 00 28 addi r21,r1,40
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
*time_of_context_switch = _Thread_Time_of_last_context_switch;
ffc052f0: 81 69 00 20 lwz r11,32(r9)
ffc052f4: 91 41 00 18 stw r10,24(r1)
ffc052f8: 91 61 00 1c stw r11,28(r1)
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
if ( is_executing_on_a_core( the_thread, &last ) ) {
Timestamp_Control used;
_TOD_Get_uptime( &uptime );
ffc052fc: 48 00 6e f1 bl ffc0c1ec <_TOD_Get_uptime>
_Timestamp_Subtract( &last, &uptime, &used );
ffc05300: 38 61 00 18 addi r3,r1,24
ffc05304: 38 81 00 38 addi r4,r1,56
ffc05308: 38 a1 00 10 addi r5,r1,16
ffc0530c: 48 00 9e 19 bl ffc0f124 <_Timespec_Subtract>
_Timestamp_Add_to( &ran, &used );
ffc05310: 7e a3 ab 78 mr r3,r21
ffc05314: 38 81 00 10 addi r4,r1,16
ffc05318: 48 00 9c a5 bl ffc0efbc <_Timespec_Add_to>
ffc0531c: 4b ff fe f0 b ffc0520c <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++ ) {
ffc05320: 7f 98 b8 00 cmpw cr7,r24,r23
ffc05324: 40 9e fe c0 bne+ cr7,ffc051e4 <rtems_cpu_usage_report_with_plugin+0xac>
}
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)(
ffc05328: 3c 00 10 62 lis r0,4194
ffc0532c: 80 c1 00 34 lwz r6,52(r1)
ffc05330: 60 00 4d d3 ori r0,r0,19923
ffc05334: 80 a1 00 30 lwz r5,48(r1)
ffc05338: 7c c6 00 16 mulhwu r6,r6,r0
ffc0533c: 80 01 00 58 lwz r0,88(r1)
ffc05340: 3c 80 ff c2 lis r4,-62
ffc05344: 7c 09 03 a6 mtctr r0
ffc05348: 7f a3 eb 78 mr r3,r29
ffc0534c: 38 84 2f f0 addi r4,r4,12272
ffc05350: 54 c6 d1 be rlwinm r6,r6,26,6,31
ffc05354: 4c c6 31 82 crclr 4*cr1+eq
ffc05358: 4e 80 04 21 bctrl
"-------------------------------------------------------------------------------\n",
_Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset,
total_units
);
#endif
}
ffc0535c: 80 01 00 94 lwz r0,148(r1)
ffc05360: 82 a1 00 64 lwz r21,100(r1)
ffc05364: 7c 08 03 a6 mtlr r0
ffc05368: 82 c1 00 68 lwz r22,104(r1)
ffc0536c: 82 e1 00 6c lwz r23,108(r1)
ffc05370: 83 01 00 70 lwz r24,112(r1)
ffc05374: 83 21 00 74 lwz r25,116(r1)
ffc05378: 83 41 00 78 lwz r26,120(r1)
ffc0537c: 83 61 00 7c lwz r27,124(r1)
ffc05380: 83 81 00 80 lwz r28,128(r1)
ffc05384: 83 a1 00 84 lwz r29,132(r1)
ffc05388: 83 c1 00 88 lwz r30,136(r1)
ffc0538c: 83 e1 00 8c lwz r31,140(r1)
ffc05390: 38 21 00 90 addi r1,r1,144
ffc05394: 4e 80 00 20 blr
ffc13ca4 <rtems_deviceio_errno>:
[RTEMS_IO_ERROR] = EIO,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
ffc13ca4: 94 21 ff f0 stwu r1,-16(r1)
ffc13ca8: 7c 08 02 a6 mflr r0
ffc13cac: 90 01 00 14 stw r0,20(r1)
if (sc == RTEMS_SUCCESSFUL) {
ffc13cb0: 7c 60 1b 79 mr. r0,r3
return 0;
ffc13cb4: 38 60 00 00 li r3,0
[RTEMS_IO_ERROR] = EIO,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
ffc13cb8: 93 e1 00 0c stw r31,12(r1)
if (sc == RTEMS_SUCCESSFUL) {
ffc13cbc: 40 82 00 18 bne- ffc13cd4 <rtems_deviceio_errno+0x30>
errno = eno;
return -1;
}
}
ffc13cc0: 80 01 00 14 lwz r0,20(r1)
ffc13cc4: 83 e1 00 0c lwz r31,12(r1)
ffc13cc8: 38 21 00 10 addi r1,r1,16
ffc13ccc: 7c 08 03 a6 mtlr r0
ffc13cd0: 4e 80 00 20 blr
if (sc == RTEMS_SUCCESSFUL) {
return 0;
} else {
int eno = EINVAL;
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
ffc13cd4: 2b 80 00 1c cmplwi cr7,r0,28
int rtems_deviceio_errno(rtems_status_code sc)
{
if (sc == RTEMS_SUCCESSFUL) {
return 0;
} else {
int eno = EINVAL;
ffc13cd8: 3b e0 00 16 li r31,22
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
ffc13cdc: 41 9d 00 14 bgt- cr7,ffc13cf0 <rtems_deviceio_errno+0x4c><== NEVER TAKEN
eno = status_code_to_errno [sc];
ffc13ce0: 3d 20 ff c2 lis r9,-62
ffc13ce4: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc13ce8: 39 29 10 e8 addi r9,r9,4328
ffc13cec: 7f e9 00 2e lwzx r31,r9,r0
}
errno = eno;
ffc13cf0: 48 00 00 9d bl ffc13d8c <__errno>
ffc13cf4: 93 e3 00 00 stw r31,0(r3)
return -1;
ffc13cf8: 38 60 ff ff li r3,-1
ffc13cfc: 4b ff ff c4 b ffc13cc0 <rtems_deviceio_errno+0x1c>
ffc04844 <rtems_disk_create_log>:
dev_t phys,
rtems_blkdev_bnum begin_block,
rtems_blkdev_bnum block_count,
const char *name
)
{
ffc04844: 94 21 ff c0 stwu r1,-64(r1)
ffc04848: 7c 08 02 a6 mflr r0
ffc0484c: 90 01 00 44 stw r0,68(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *physical_disk = NULL;
rtems_disk_device *dd = NULL;
ffc04850: 38 00 00 00 li r0,0
dev_t phys,
rtems_blkdev_bnum begin_block,
rtems_blkdev_bnum block_count,
const char *name
)
{
ffc04854: 93 21 00 24 stw r25,36(r1)
ffc04858: 7d 39 4b 78 mr r25,r9
ffc0485c: 93 41 00 28 stw r26,40(r1)
ffc04860: 7c ba 2b 78 mr r26,r5
ffc04864: 93 61 00 2c stw r27,44(r1)
ffc04868: 7c db 33 78 mr r27,r6
ffc0486c: 93 81 00 30 stw r28,48(r1)
ffc04870: 7d 1c 43 78 mr r28,r8
ffc04874: 93 a1 00 34 stw r29,52(r1)
ffc04878: 7c fd 3b 78 mr r29,r7
ffc0487c: 93 c1 00 38 stw r30,56(r1)
ffc04880: 7c 7e 1b 78 mr r30,r3
ffc04884: 93 e1 00 3c stw r31,60(r1)
ffc04888: 7c 9f 23 78 mr r31,r4
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *physical_disk = NULL;
rtems_disk_device *dd = NULL;
ffc0488c: 90 01 00 08 stw r0,8(r1)
rtems_blkdev_bnum end_block = begin_block + block_count;
sc = disk_lock();
ffc04890: 4b ff fb c9 bl ffc04458 <disk_lock>
if (sc != RTEMS_SUCCESSFUL) {
ffc04894: 2c 03 00 00 cmpwi r3,0
ffc04898: 41 82 00 30 beq- ffc048c8 <rtems_disk_create_log+0x84> <== ALWAYS TAKEN
++physical_disk->uses;
disk_unlock();
return RTEMS_SUCCESSFUL;
}
ffc0489c: 80 01 00 44 lwz r0,68(r1)
ffc048a0: 83 21 00 24 lwz r25,36(r1)
ffc048a4: 7c 08 03 a6 mtlr r0
ffc048a8: 83 41 00 28 lwz r26,40(r1)
ffc048ac: 83 61 00 2c lwz r27,44(r1)
ffc048b0: 83 81 00 30 lwz r28,48(r1)
ffc048b4: 83 a1 00 34 lwz r29,52(r1)
ffc048b8: 83 c1 00 38 lwz r30,56(r1)
ffc048bc: 83 e1 00 3c lwz r31,60(r1)
ffc048c0: 38 21 00 40 addi r1,r1,64
ffc048c4: 4e 80 00 20 blr
sc = disk_lock();
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
physical_disk = get_disk_entry(phys, true);
ffc048c8: 7f 43 d3 78 mr r3,r26
ffc048cc: 7f 64 db 78 mr r4,r27
ffc048d0: 38 a0 00 01 li r5,1
ffc048d4: 4b ff fa 8d bl ffc04360 <get_disk_entry>
if (physical_disk == NULL || !is_physical_disk(physical_disk)) {
ffc048d8: 7c 7a 1b 79 mr. r26,r3
ffc048dc: 41 82 00 10 beq- ffc048ec <rtems_disk_create_log+0xa8>
ffc048e0: 80 1a 00 08 lwz r0,8(r26)
ffc048e4: 7f 9a 00 00 cmpw cr7,r26,r0
ffc048e8: 41 9e 00 38 beq- cr7,ffc04920 <rtems_disk_create_log+0xdc>
disk_unlock();
ffc048ec: 4b ff fb d5 bl ffc044c0 <disk_unlock>
++physical_disk->uses;
disk_unlock();
return RTEMS_SUCCESSFUL;
}
ffc048f0: 80 01 00 44 lwz r0,68(r1)
physical_disk = get_disk_entry(phys, true);
if (physical_disk == NULL || !is_physical_disk(physical_disk)) {
disk_unlock();
return RTEMS_INVALID_ID;
ffc048f4: 38 60 00 04 li r3,4
++physical_disk->uses;
disk_unlock();
return RTEMS_SUCCESSFUL;
}
ffc048f8: 83 21 00 24 lwz r25,36(r1)
ffc048fc: 7c 08 03 a6 mtlr r0
ffc04900: 83 41 00 28 lwz r26,40(r1)
ffc04904: 83 61 00 2c lwz r27,44(r1)
ffc04908: 83 81 00 30 lwz r28,48(r1)
ffc0490c: 83 a1 00 34 lwz r29,52(r1)
ffc04910: 83 c1 00 38 lwz r30,56(r1)
ffc04914: 83 e1 00 3c lwz r31,60(r1)
ffc04918: 38 21 00 40 addi r1,r1,64
ffc0491c: 4e 80 00 20 blr
return RTEMS_INVALID_ID;
}
if (
begin_block >= physical_disk->size
ffc04920: 80 1a 00 1c lwz r0,28(r26)
disk_unlock();
return RTEMS_INVALID_ID;
}
if (
ffc04924: 7f 9d 00 40 cmplw cr7,r29,r0
ffc04928: 40 9c 00 10 bge- cr7,ffc04938 <rtems_disk_create_log+0xf4>
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *physical_disk = NULL;
rtems_disk_device *dd = NULL;
rtems_blkdev_bnum end_block = begin_block + block_count;
ffc0492c: 7d 3c ea 14 add r9,r28,r29
return RTEMS_INVALID_ID;
}
if (
begin_block >= physical_disk->size
|| end_block <= begin_block
ffc04930: 7f 9d 48 40 cmplw cr7,r29,r9
ffc04934: 41 9c 00 10 blt- cr7,ffc04944 <rtems_disk_create_log+0x100><== ALWAYS TAKEN
|| end_block > physical_disk->size
) {
disk_unlock();
ffc04938: 4b ff fb 89 bl ffc044c0 <disk_unlock>
return RTEMS_INVALID_NUMBER;
ffc0493c: 38 60 00 0a li r3,10
ffc04940: 4b ff ff 5c b ffc0489c <rtems_disk_create_log+0x58>
}
if (
begin_block >= physical_disk->size
|| end_block <= begin_block
|| end_block > physical_disk->size
ffc04944: 7f 89 00 40 cmplw cr7,r9,r0
ffc04948: 41 9d ff f0 bgt+ cr7,ffc04938 <rtems_disk_create_log+0xf4>
disk_unlock();
return RTEMS_INVALID_NUMBER;
}
sc = create_disk(dev, name, &dd);
ffc0494c: 7f c3 f3 78 mr r3,r30
ffc04950: 7f e4 fb 78 mr r4,r31
ffc04954: 7f 25 cb 78 mr r5,r25
ffc04958: 38 c1 00 08 addi r6,r1,8
ffc0495c: 4b ff fb ad bl ffc04508 <create_disk>
if (sc != RTEMS_SUCCESSFUL) {
ffc04960: 2c 03 00 00 cmpwi r3,0
ffc04964: 40 82 00 3c bne- ffc049a0 <rtems_disk_create_log+0x15c>
dd->size = block_count;
dd->block_size = dd->media_block_size = physical_disk->block_size;
dd->ioctl = physical_disk->ioctl;
dd->driver_data = physical_disk->driver_data;
++physical_disk->uses;
ffc04968: 81 7a 00 14 lwz r11,20(r26)
disk_unlock();
return sc;
}
dd->phys_dev = physical_disk;
ffc0496c: 81 21 00 08 lwz r9,8(r1)
dd->start = begin_block;
dd->size = block_count;
dd->block_size = dd->media_block_size = physical_disk->block_size;
ffc04970: 80 1a 00 20 lwz r0,32(r26)
dd->ioctl = physical_disk->ioctl;
dd->driver_data = physical_disk->driver_data;
++physical_disk->uses;
ffc04974: 39 6b 00 01 addi r11,r11,1
dd->phys_dev = physical_disk;
dd->start = begin_block;
dd->size = block_count;
dd->block_size = dd->media_block_size = physical_disk->block_size;
dd->ioctl = physical_disk->ioctl;
ffc04978: 81 1a 00 28 lwz r8,40(r26)
dd->driver_data = physical_disk->driver_data;
ffc0497c: 81 5a 00 2c lwz r10,44(r26)
disk_unlock();
return sc;
}
dd->phys_dev = physical_disk;
ffc04980: 93 49 00 08 stw r26,8(r9)
dd->start = begin_block;
ffc04984: 93 a9 00 18 stw r29,24(r9)
dd->size = block_count;
ffc04988: 93 89 00 1c stw r28,28(r9)
dd->block_size = dd->media_block_size = physical_disk->block_size;
ffc0498c: 90 09 00 24 stw r0,36(r9)
ffc04990: 90 09 00 20 stw r0,32(r9)
dd->ioctl = physical_disk->ioctl;
ffc04994: 91 09 00 28 stw r8,40(r9)
dd->driver_data = physical_disk->driver_data;
ffc04998: 91 49 00 2c stw r10,44(r9)
++physical_disk->uses;
ffc0499c: 91 7a 00 14 stw r11,20(r26)
disk_unlock();
ffc049a0: 90 61 00 18 stw r3,24(r1)
ffc049a4: 4b ff fb 1d bl ffc044c0 <disk_unlock>
ffc049a8: 80 61 00 18 lwz r3,24(r1)
return RTEMS_SUCCESSFUL;
ffc049ac: 4b ff fe f0 b ffc0489c <rtems_disk_create_log+0x58>
ffc04734 <rtems_disk_create_phys>:
rtems_blkdev_bnum block_count,
rtems_block_device_ioctl handler,
void *driver_data,
const char *name
)
{
ffc04734: 94 21 ff c8 stwu r1,-56(r1)
ffc04738: 7c 08 02 a6 mflr r0
ffc0473c: 93 c1 00 30 stw r30,48(r1)
rtems_disk_device *dd = NULL;
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (handler == NULL) {
ffc04740: 7c fe 3b 79 mr. r30,r7
rtems_blkdev_bnum block_count,
rtems_block_device_ioctl handler,
void *driver_data,
const char *name
)
{
ffc04744: 90 01 00 3c stw r0,60(r1)
rtems_disk_device *dd = NULL;
ffc04748: 38 00 00 00 li r0,0
rtems_blkdev_bnum block_count,
rtems_block_device_ioctl handler,
void *driver_data,
const char *name
)
{
ffc0474c: 93 41 00 20 stw r26,32(r1)
rtems_disk_device *dd = NULL;
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (handler == NULL) {
return RTEMS_INVALID_ADDRESS;
ffc04750: 3b 40 00 09 li r26,9
rtems_blkdev_bnum block_count,
rtems_block_device_ioctl handler,
void *driver_data,
const char *name
)
{
ffc04754: 93 61 00 24 stw r27,36(r1)
ffc04758: 7c db 33 78 mr r27,r6
ffc0475c: 93 81 00 28 stw r28,40(r1)
ffc04760: 7c 7c 1b 78 mr r28,r3
ffc04764: 93 a1 00 2c stw r29,44(r1)
ffc04768: 7c 9d 23 78 mr r29,r4
ffc0476c: 93 e1 00 34 stw r31,52(r1)
ffc04770: 7c bf 2b 78 mr r31,r5
rtems_disk_device *dd = NULL;
ffc04774: 90 01 00 08 stw r0,8(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (handler == NULL) {
ffc04778: 41 82 00 10 beq- ffc04788 <rtems_disk_create_phys+0x54>
return RTEMS_INVALID_ADDRESS;
}
if (block_size == 0) {
ffc0477c: 2f 85 00 00 cmpwi cr7,r5,0
return RTEMS_INVALID_NUMBER;
ffc04780: 3b 40 00 0a li r26,10
if (handler == NULL) {
return RTEMS_INVALID_ADDRESS;
}
if (block_size == 0) {
ffc04784: 40 9e 00 30 bne- cr7,ffc047b4 <rtems_disk_create_phys+0x80>
}
disk_unlock();
return RTEMS_SUCCESSFUL;
}
ffc04788: 80 01 00 3c lwz r0,60(r1)
ffc0478c: 7f 43 d3 78 mr r3,r26
ffc04790: 83 61 00 24 lwz r27,36(r1)
ffc04794: 7c 08 03 a6 mtlr r0
ffc04798: 83 41 00 20 lwz r26,32(r1)
ffc0479c: 83 81 00 28 lwz r28,40(r1)
ffc047a0: 83 a1 00 2c lwz r29,44(r1)
ffc047a4: 83 c1 00 30 lwz r30,48(r1)
ffc047a8: 83 e1 00 34 lwz r31,52(r1)
ffc047ac: 38 21 00 38 addi r1,r1,56
ffc047b0: 4e 80 00 20 blr
if (block_size == 0) {
return RTEMS_INVALID_NUMBER;
}
sc = disk_lock();
ffc047b4: 91 21 00 18 stw r9,24(r1)
ffc047b8: 91 01 00 1c stw r8,28(r1)
ffc047bc: 4b ff fc 9d bl ffc04458 <disk_lock>
if (sc != RTEMS_SUCCESSFUL) {
ffc047c0: 7c 7a 1b 79 mr. r26,r3
ffc047c4: 81 21 00 18 lwz r9,24(r1)
ffc047c8: 40 82 ff c0 bne+ ffc04788 <rtems_disk_create_phys+0x54> <== NEVER TAKEN
return sc;
}
sc = create_disk(dev, name, &dd);
ffc047cc: 7f 83 e3 78 mr r3,r28
ffc047d0: 7f a4 eb 78 mr r4,r29
ffc047d4: 7d 25 4b 78 mr r5,r9
ffc047d8: 38 c1 00 08 addi r6,r1,8
ffc047dc: 4b ff fd 2d bl ffc04508 <create_disk>
if (sc != RTEMS_SUCCESSFUL) {
ffc047e0: 81 01 00 1c lwz r8,28(r1)
ffc047e4: 7c 7a 1b 79 mr. r26,r3
ffc047e8: 40 82 00 44 bne- ffc0482c <rtems_disk_create_phys+0xf8>
disk_unlock();
return sc;
}
dd->phys_dev = dd;
ffc047ec: 81 21 00 08 lwz r9,8(r1)
dd->size = block_count;
dd->block_size = dd->media_block_size = block_size;
dd->ioctl = handler;
dd->driver_data = driver_data;
if ((*handler)(dd, RTEMS_BLKIO_CAPABILITIES, &dd->capabilities) < 0) {
ffc047f0: 3c 80 20 00 lis r4,8192
ffc047f4: 60 84 42 08 ori r4,r4,16904
ffc047f8: 7f c9 03 a6 mtctr r30
ffc047fc: 7d 23 4b 78 mr r3,r9
disk_unlock();
return sc;
}
dd->phys_dev = dd;
ffc04800: 91 29 00 08 stw r9,8(r9)
dd->size = block_count;
dd->block_size = dd->media_block_size = block_size;
dd->ioctl = handler;
dd->driver_data = driver_data;
if ((*handler)(dd, RTEMS_BLKIO_CAPABILITIES, &dd->capabilities) < 0) {
ffc04804: 38 a9 00 0c addi r5,r9,12
return sc;
}
dd->phys_dev = dd;
dd->start = 0;
ffc04808: 93 49 00 18 stw r26,24(r9)
dd->size = block_count;
ffc0480c: 93 69 00 1c stw r27,28(r9)
dd->block_size = dd->media_block_size = block_size;
ffc04810: 93 e9 00 24 stw r31,36(r9)
ffc04814: 93 e9 00 20 stw r31,32(r9)
dd->ioctl = handler;
ffc04818: 93 c9 00 28 stw r30,40(r9)
dd->driver_data = driver_data;
ffc0481c: 91 09 00 2c stw r8,44(r9)
if ((*handler)(dd, RTEMS_BLKIO_CAPABILITIES, &dd->capabilities) < 0) {
ffc04820: 4e 80 04 21 bctrl
ffc04824: 2f 83 00 00 cmpwi cr7,r3,0
ffc04828: 41 9c 00 0c blt- cr7,ffc04834 <rtems_disk_create_phys+0x100><== ALWAYS TAKEN
dd->capabilities = 0;
}
disk_unlock();
ffc0482c: 4b ff fc 95 bl ffc044c0 <disk_unlock>
return RTEMS_SUCCESSFUL;
ffc04830: 4b ff ff 58 b ffc04788 <rtems_disk_create_phys+0x54>
dd->block_size = dd->media_block_size = block_size;
dd->ioctl = handler;
dd->driver_data = driver_data;
if ((*handler)(dd, RTEMS_BLKIO_CAPABILITIES, &dd->capabilities) < 0) {
dd->capabilities = 0;
ffc04834: 81 21 00 08 lwz r9,8(r1)
ffc04838: 93 49 00 0c stw r26,12(r9)
}
disk_unlock();
ffc0483c: 4b ff fc 85 bl ffc044c0 <disk_unlock>
ffc04840: 4b ff ff 48 b ffc04788 <rtems_disk_create_phys+0x54>
ffc049b0 <rtems_disk_delete>:
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
{
ffc049b0: 94 21 ff c8 stwu r1,-56(r1)
ffc049b4: 7c 08 02 a6 mflr r0
ffc049b8: 93 81 00 28 stw r28,40(r1)
ffc049bc: 7c 7c 1b 78 mr r28,r3
ffc049c0: 93 a1 00 2c stw r29,44(r1)
ffc049c4: 7c 9d 23 78 mr r29,r4
ffc049c8: 93 e1 00 34 stw r31,52(r1)
ffc049cc: 90 01 00 3c stw r0,60(r1)
ffc049d0: 92 a1 00 0c stw r21,12(r1)
ffc049d4: 92 c1 00 10 stw r22,16(r1)
ffc049d8: 92 e1 00 14 stw r23,20(r1)
ffc049dc: 93 01 00 18 stw r24,24(r1)
ffc049e0: 93 21 00 1c stw r25,28(r1)
ffc049e4: 93 41 00 20 stw r26,32(r1)
ffc049e8: 93 61 00 24 stw r27,36(r1)
ffc049ec: 93 c1 00 30 stw r30,48(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
sc = disk_lock();
ffc049f0: 4b ff fa 69 bl ffc04458 <disk_lock>
if (sc != RTEMS_SUCCESSFUL) {
ffc049f4: 7c 7f 1b 79 mr. r31,r3
ffc049f8: 41 82 00 44 beq- ffc04a3c <rtems_disk_delete+0x8c> <== ALWAYS TAKEN
rtems_disk_cleanup(dd);
disk_unlock();
return RTEMS_SUCCESSFUL;
}
ffc049fc: 80 01 00 3c lwz r0,60(r1) <== NOT EXECUTED
ffc04a00: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc04a04: 82 a1 00 0c lwz r21,12(r1) <== NOT EXECUTED
ffc04a08: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc04a0c: 82 c1 00 10 lwz r22,16(r1) <== NOT EXECUTED
ffc04a10: 82 e1 00 14 lwz r23,20(r1) <== NOT EXECUTED
ffc04a14: 83 01 00 18 lwz r24,24(r1) <== NOT EXECUTED
ffc04a18: 83 21 00 1c lwz r25,28(r1) <== NOT EXECUTED
ffc04a1c: 83 41 00 20 lwz r26,32(r1) <== NOT EXECUTED
ffc04a20: 83 61 00 24 lwz r27,36(r1) <== NOT EXECUTED
ffc04a24: 83 81 00 28 lwz r28,40(r1) <== NOT EXECUTED
ffc04a28: 83 a1 00 2c lwz r29,44(r1) <== NOT EXECUTED
ffc04a2c: 83 c1 00 30 lwz r30,48(r1) <== NOT EXECUTED
ffc04a30: 83 e1 00 34 lwz r31,52(r1) <== NOT EXECUTED
ffc04a34: 38 21 00 38 addi r1,r1,56 <== NOT EXECUTED
ffc04a38: 4e 80 00 20 blr <== NOT EXECUTED
sc = disk_lock();
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
dd = get_disk_entry(dev, true);
ffc04a3c: 7f 83 e3 78 mr r3,r28
ffc04a40: 7f a4 eb 78 mr r4,r29
ffc04a44: 38 a0 00 01 li r5,1
ffc04a48: 4b ff f9 19 bl ffc04360 <get_disk_entry>
if (dd == NULL) {
ffc04a4c: 7c 69 1b 79 mr. r9,r3
ffc04a50: 41 82 01 88 beq- ffc04bd8 <rtems_disk_delete+0x228> <== NEVER TAKEN
disk_unlock();
return RTEMS_INVALID_ID;
}
dd->deleted = true;
ffc04a54: 38 00 00 01 li r0,1
}
static void
rtems_disk_cleanup(rtems_disk_device *disk_to_remove)
{
rtems_disk_device *const physical_disk = disk_to_remove->phys_dev;
ffc04a58: 83 49 00 08 lwz r26,8(r9)
disk_unlock();
return RTEMS_INVALID_ID;
}
dd->deleted = true;
ffc04a5c: 98 09 00 30 stb r0,48(r9)
{
rtems_disk_device *const physical_disk = disk_to_remove->phys_dev;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
if (physical_disk->deleted) {
ffc04a60: 88 1a 00 30 lbz r0,48(r26)
ffc04a64: 2f 80 00 00 cmpwi cr7,r0,0
ffc04a68: 41 9e 01 18 beq- cr7,ffc04b80 <rtems_disk_delete+0x1d0>
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
ffc04a6c: 3e a0 00 00 lis r21,0
rtems_disk_device *const physical_disk = disk_to_remove->phys_dev;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
ffc04a70: 83 ba 00 00 lwz r29,0(r26)
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
ffc04a74: 80 15 28 e8 lwz r0,10472(r21)
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
ffc04a78: 3a c0 00 00 li r22,0
rtems_disk_device *const physical_disk = disk_to_remove->phys_dev;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
ffc04a7c: 83 3a 00 04 lwz r25,4(r26)
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
ffc04a80: 2f 80 00 00 cmpwi cr7,r0,0
ffc04a84: 41 9e 00 a4 beq- cr7,ffc04b28 <rtems_disk_delete+0x178> <== NEVER TAKEN
ffc04a88: 7f f6 fb 78 mr r22,r31
ffc04a8c: 3b 60 00 00 li r27,0
ffc04a90: 3b 15 28 e8 addi r24,r21,10472
if (dd->uses == 0) {
++deleted_count;
dtab->minor [minor] = NULL;
free_disk_device(dd);
} else {
dd->deleted = true;
ffc04a94: 3a e0 00 01 li r23,1
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
ffc04a98: 83 d8 00 04 lwz r30,4(r24)
ffc04a9c: 57 60 18 38 rlwinm r0,r27,3,0,28
ffc04aa0: 7f de 02 14 add r30,r30,r0
for (minor = 0; minor < dtab->size; ++minor) {
ffc04aa4: 81 1e 00 04 lwz r8,4(r30)
ffc04aa8: 2f 88 00 00 cmpwi cr7,r8,0
ffc04aac: 41 9e 00 6c beq- cr7,ffc04b18 <rtems_disk_delete+0x168>
ffc04ab0: 3b 80 00 00 li r28,0
ffc04ab4: 48 00 00 10 b ffc04ac4 <rtems_disk_delete+0x114>
ffc04ab8: 3b 9c 00 01 addi r28,r28,1
ffc04abc: 7f 9c 40 40 cmplw cr7,r28,r8
ffc04ac0: 40 9c 00 58 bge- cr7,ffc04b18 <rtems_disk_delete+0x168>
rtems_disk_device *dd = dtab->minor [minor];
ffc04ac4: 81 3e 00 00 lwz r9,0(r30)
ffc04ac8: 57 80 10 3a rlwinm r0,r28,2,0,29
ffc04acc: 7c 69 00 2e lwzx r3,r9,r0
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
ffc04ad0: 2f 83 00 00 cmpwi cr7,r3,0
ffc04ad4: 41 be ff e4 beq- cr7,ffc04ab8 <rtems_disk_delete+0x108>
ffc04ad8: 81 63 00 08 lwz r11,8(r3)
ffc04adc: 81 4b 00 00 lwz r10,0(r11)
ffc04ae0: 7f 8a e8 00 cmpw cr7,r10,r29
ffc04ae4: 40 9e ff d4 bne+ cr7,ffc04ab8 <rtems_disk_delete+0x108> <== NEVER TAKEN
ffc04ae8: 81 6b 00 04 lwz r11,4(r11)
ffc04aec: 7f 8b c8 00 cmpw cr7,r11,r25
ffc04af0: 40 9e ff c8 bne+ cr7,ffc04ab8 <rtems_disk_delete+0x108> <== NEVER TAKEN
ffc04af4: 7f 9a 18 00 cmpw cr7,r26,r3
ffc04af8: 41 be ff c0 beq- cr7,ffc04ab8 <rtems_disk_delete+0x108>
if (dd->uses == 0) {
ffc04afc: 81 63 00 14 lwz r11,20(r3)
ffc04b00: 2f 8b 00 00 cmpwi cr7,r11,0
ffc04b04: 41 9e 00 c0 beq- cr7,ffc04bc4 <rtems_disk_delete+0x214>
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
for (minor = 0; minor < dtab->size; ++minor) {
ffc04b08: 3b 9c 00 01 addi r28,r28,1
if (dd->uses == 0) {
++deleted_count;
dtab->minor [minor] = NULL;
free_disk_device(dd);
} else {
dd->deleted = true;
ffc04b0c: 9a e3 00 30 stb r23,48(r3)
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
for (minor = 0; minor < dtab->size; ++minor) {
ffc04b10: 7f 9c 40 40 cmplw cr7,r28,r8
ffc04b14: 41 9c ff b0 blt+ cr7,ffc04ac4 <rtems_disk_delete+0x114> <== ALWAYS TAKEN
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
ffc04b18: 80 18 00 00 lwz r0,0(r24)
ffc04b1c: 3b 7b 00 01 addi r27,r27,1
ffc04b20: 7f 9b 00 40 cmplw cr7,r27,r0
ffc04b24: 41 9c ff 74 blt+ cr7,ffc04a98 <rtems_disk_delete+0xe8>
}
}
}
}
physical_disk->uses -= deleted_count;
ffc04b28: 80 1a 00 14 lwz r0,20(r26)
ffc04b2c: 7e d6 00 50 subf r22,r22,r0
if (physical_disk->uses == 0) {
ffc04b30: 2f 96 00 00 cmpwi cr7,r22,0
}
}
}
}
physical_disk->uses -= deleted_count;
ffc04b34: 92 da 00 14 stw r22,20(r26)
if (physical_disk->uses == 0) {
ffc04b38: 41 9e 00 e8 beq- cr7,ffc04c20 <rtems_disk_delete+0x270>
}
dd->deleted = true;
rtems_disk_cleanup(dd);
disk_unlock();
ffc04b3c: 4b ff f9 85 bl ffc044c0 <disk_unlock>
return RTEMS_SUCCESSFUL;
}
ffc04b40: 80 01 00 3c lwz r0,60(r1)
ffc04b44: 7f e3 fb 78 mr r3,r31
ffc04b48: 82 a1 00 0c lwz r21,12(r1)
ffc04b4c: 7c 08 03 a6 mtlr r0
ffc04b50: 82 c1 00 10 lwz r22,16(r1)
ffc04b54: 82 e1 00 14 lwz r23,20(r1)
ffc04b58: 83 01 00 18 lwz r24,24(r1)
ffc04b5c: 83 21 00 1c lwz r25,28(r1)
ffc04b60: 83 41 00 20 lwz r26,32(r1)
ffc04b64: 83 61 00 24 lwz r27,36(r1)
ffc04b68: 83 81 00 28 lwz r28,40(r1)
ffc04b6c: 83 a1 00 2c lwz r29,44(r1)
ffc04b70: 83 c1 00 30 lwz r30,48(r1)
ffc04b74: 83 e1 00 34 lwz r31,52(r1)
ffc04b78: 38 21 00 38 addi r1,r1,56
ffc04b7c: 4e 80 00 20 blr
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
disktab [major].minor [minor] = NULL;
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
ffc04b80: 80 09 00 14 lwz r0,20(r9)
ffc04b84: 2f 80 00 00 cmpwi cr7,r0,0
ffc04b88: 40 9e ff b4 bne+ cr7,ffc04b3c <rtems_disk_delete+0x18c> <== NEVER TAKEN
--physical_disk->uses;
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
ffc04b8c: 81 09 00 00 lwz r8,0(r9)
disktab [major].minor [minor] = NULL;
ffc04b90: 3d 60 00 00 lis r11,0
ffc04b94: 81 4b 28 ec lwz r10,10476(r11)
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
ffc04b98: 80 09 00 04 lwz r0,4(r9)
disktab [major].minor [minor] = NULL;
ffc04b9c: 55 09 18 38 rlwinm r9,r8,3,0,28
disktab [major].minor [minor] = NULL;
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
ffc04ba0: 81 7a 00 14 lwz r11,20(r26)
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
disktab [major].minor [minor] = NULL;
ffc04ba4: 7d 2a 48 2e lwzx r9,r10,r9
ffc04ba8: 54 00 10 3a rlwinm r0,r0,2,0,29
disktab [major].minor [minor] = NULL;
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
ffc04bac: 39 6b ff ff addi r11,r11,-1
ffc04bb0: 91 7a 00 14 stw r11,20(r26)
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
disktab [major].minor [minor] = NULL;
ffc04bb4: 7f e9 01 2e stwx r31,r9,r0
free_disk_device(disk_to_remove);
ffc04bb8: 4b ff f8 31 bl ffc043e8 <free_disk_device>
}
dd->deleted = true;
rtems_disk_cleanup(dd);
disk_unlock();
ffc04bbc: 4b ff f9 05 bl ffc044c0 <disk_unlock>
ffc04bc0: 4b ff ff 80 b ffc04b40 <rtems_disk_delete+0x190>
rtems_disk_device *dd = dtab->minor [minor];
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
if (dd->uses == 0) {
++deleted_count;
dtab->minor [minor] = NULL;
ffc04bc4: 7d 69 01 2e stwx r11,r9,r0
for (minor = 0; minor < dtab->size; ++minor) {
rtems_disk_device *dd = dtab->minor [minor];
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
if (dd->uses == 0) {
++deleted_count;
ffc04bc8: 3a d6 00 01 addi r22,r22,1
dtab->minor [minor] = NULL;
free_disk_device(dd);
ffc04bcc: 4b ff f8 1d bl ffc043e8 <free_disk_device>
ffc04bd0: 81 1e 00 04 lwz r8,4(r30)
ffc04bd4: 4b ff fe e4 b ffc04ab8 <rtems_disk_delete+0x108>
return sc;
}
dd = get_disk_entry(dev, true);
if (dd == NULL) {
disk_unlock();
ffc04bd8: 4b ff f8 e9 bl ffc044c0 <disk_unlock> <== NOT EXECUTED
rtems_disk_cleanup(dd);
disk_unlock();
return RTEMS_SUCCESSFUL;
}
ffc04bdc: 80 01 00 3c lwz r0,60(r1) <== NOT EXECUTED
dd = get_disk_entry(dev, true);
if (dd == NULL) {
disk_unlock();
return RTEMS_INVALID_ID;
ffc04be0: 3b e0 00 04 li r31,4 <== NOT EXECUTED
rtems_disk_cleanup(dd);
disk_unlock();
return RTEMS_SUCCESSFUL;
}
ffc04be4: 82 a1 00 0c lwz r21,12(r1) <== NOT EXECUTED
ffc04be8: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc04bec: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc04bf0: 82 c1 00 10 lwz r22,16(r1) <== NOT EXECUTED
ffc04bf4: 82 e1 00 14 lwz r23,20(r1) <== NOT EXECUTED
ffc04bf8: 83 01 00 18 lwz r24,24(r1) <== NOT EXECUTED
ffc04bfc: 83 21 00 1c lwz r25,28(r1) <== NOT EXECUTED
ffc04c00: 83 41 00 20 lwz r26,32(r1) <== NOT EXECUTED
ffc04c04: 83 61 00 24 lwz r27,36(r1) <== NOT EXECUTED
ffc04c08: 83 81 00 28 lwz r28,40(r1) <== NOT EXECUTED
ffc04c0c: 83 a1 00 2c lwz r29,44(r1) <== NOT EXECUTED
ffc04c10: 83 c1 00 30 lwz r30,48(r1) <== NOT EXECUTED
ffc04c14: 83 e1 00 34 lwz r31,52(r1) <== NOT EXECUTED
ffc04c18: 38 21 00 38 addi r1,r1,56 <== NOT EXECUTED
ffc04c1c: 4e 80 00 20 blr <== NOT EXECUTED
}
}
physical_disk->uses -= deleted_count;
if (physical_disk->uses == 0) {
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
ffc04c20: 81 3a 00 00 lwz r9,0(r26)
disktab [major].minor [minor] = NULL;
ffc04c24: 3a b5 28 e8 addi r21,r21,10472
ffc04c28: 81 75 00 04 lwz r11,4(r21)
free_disk_device(physical_disk);
ffc04c2c: 7f 43 d3 78 mr r3,r26
}
}
physical_disk->uses -= deleted_count;
if (physical_disk->uses == 0) {
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
ffc04c30: 80 1a 00 04 lwz r0,4(r26)
disktab [major].minor [minor] = NULL;
ffc04c34: 55 29 18 38 rlwinm r9,r9,3,0,28
ffc04c38: 7d 2b 48 2e lwzx r9,r11,r9
ffc04c3c: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc04c40: 7e c9 01 2e stwx r22,r9,r0
free_disk_device(physical_disk);
ffc04c44: 4b ff f7 a5 bl ffc043e8 <free_disk_device>
}
dd->deleted = true;
rtems_disk_cleanup(dd);
disk_unlock();
ffc04c48: 4b ff f8 79 bl ffc044c0 <disk_unlock>
ffc04c4c: 4b ff fe f4 b ffc04b40 <rtems_disk_delete+0x190>
ffc04fd0 <rtems_disk_io_done>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_disk_io_done(void)
{
ffc04fd0: 94 21 ff e0 stwu r1,-32(r1)
ffc04fd4: 7c 08 02 a6 mflr r0
ffc04fd8: 93 61 00 0c stw r27,12(r1)
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
for (major = 0; major < disktab_size; ++major) {
ffc04fdc: 3f 60 00 00 lis r27,0
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_disk_io_done(void)
{
ffc04fe0: 90 01 00 24 stw r0,36(r1)
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
for (major = 0; major < disktab_size; ++major) {
ffc04fe4: 80 1b 28 e8 lwz r0,10472(r27)
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_disk_io_done(void)
{
ffc04fe8: 93 81 00 10 stw r28,16(r1)
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
for (major = 0; major < disktab_size; ++major) {
ffc04fec: 3b 9b 28 e8 addi r28,r27,10472
ffc04ff0: 2f 80 00 00 cmpwi cr7,r0,0
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_disk_io_done(void)
{
ffc04ff4: 93 a1 00 14 stw r29,20(r1)
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
for (major = 0; major < disktab_size; ++major) {
ffc04ff8: 3b a0 00 00 li r29,0
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_disk_io_done(void)
{
ffc04ffc: 93 e1 00 1c stw r31,28(r1)
ffc05000: 93 c1 00 18 stw r30,24(r1)
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
for (major = 0; major < disktab_size; ++major) {
ffc05004: 83 fc 00 04 lwz r31,4(r28)
ffc05008: 41 9e 00 64 beq- cr7,ffc0506c <rtems_disk_io_done+0x9c> <== NEVER TAKEN
rtems_disk_device_table *dtab = disktab + major;
ffc0500c: 57 a9 18 38 rlwinm r9,r29,3,0,28
ffc05010: 7f df 4a 14 add r30,r31,r9
for (minor = 0; minor < dtab->size; ++minor) {
ffc05014: 7d 3f 48 2e lwzx r9,r31,r9
ffc05018: 80 1e 00 04 lwz r0,4(r30)
ffc0501c: 2f 80 00 00 cmpwi cr7,r0,0
ffc05020: 41 9e 00 34 beq- cr7,ffc05054 <rtems_disk_io_done+0x84>
ffc05024: 3b e0 00 00 li r31,0
rtems_disk_device *dd = dtab->minor [minor];
ffc05028: 57 eb 10 3a rlwinm r11,r31,2,0,29
ffc0502c: 7c 69 58 2e lwzx r3,r9,r11
rtems_device_minor_number minor = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
for (minor = 0; minor < dtab->size; ++minor) {
ffc05030: 3b ff 00 01 addi r31,r31,1
rtems_disk_device *dd = dtab->minor [minor];
if (dd != NULL) {
ffc05034: 2f 83 00 00 cmpwi cr7,r3,0
ffc05038: 41 9e 00 10 beq- cr7,ffc05048 <rtems_disk_io_done+0x78>
free_disk_device(dd);
ffc0503c: 4b ff f3 ad bl ffc043e8 <free_disk_device>
ffc05040: 80 1e 00 04 lwz r0,4(r30)
ffc05044: 81 3e 00 00 lwz r9,0(r30)
rtems_device_minor_number minor = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
for (minor = 0; minor < dtab->size; ++minor) {
ffc05048: 7f 80 f8 40 cmplw cr7,r0,r31
ffc0504c: 41 9d ff dc bgt+ cr7,ffc05028 <rtems_disk_io_done+0x58>
ffc05050: 83 fc 00 04 lwz r31,4(r28)
if (dd != NULL) {
free_disk_device(dd);
}
}
free(dtab->minor);
ffc05054: 7d 23 4b 78 mr r3,r9
ffc05058: 48 00 0c c5 bl ffc05d1c <free>
rtems_disk_io_done(void)
{
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
for (major = 0; major < disktab_size; ++major) {
ffc0505c: 80 1c 00 00 lwz r0,0(r28)
ffc05060: 3b bd 00 01 addi r29,r29,1
ffc05064: 7f 80 e8 40 cmplw cr7,r0,r29
ffc05068: 41 9d ff a4 bgt+ cr7,ffc0500c <rtems_disk_io_done+0x3c>
free_disk_device(dd);
}
}
free(dtab->minor);
}
free(disktab);
ffc0506c: 7f e3 fb 78 mr r3,r31
ffc05070: 48 00 0c ad bl ffc05d1c <free>
rtems_semaphore_delete(diskdevs_mutex);
ffc05074: 80 7c 00 08 lwz r3,8(r28)
ffc05078: 48 00 50 41 bl ffc0a0b8 <rtems_semaphore_delete>
diskdevs_mutex = RTEMS_ID_NONE;
ffc0507c: 38 00 00 00 li r0,0
ffc05080: 90 1c 00 08 stw r0,8(r28)
disktab = NULL;
disktab_size = 0;
return RTEMS_SUCCESSFUL;
}
ffc05084: 38 60 00 00 li r3,0
free(disktab);
rtems_semaphore_delete(diskdevs_mutex);
diskdevs_mutex = RTEMS_ID_NONE;
disktab = NULL;
ffc05088: 90 1c 00 04 stw r0,4(r28)
disktab_size = 0;
ffc0508c: 90 1b 28 e8 stw r0,10472(r27)
return RTEMS_SUCCESSFUL;
}
ffc05090: 80 01 00 24 lwz r0,36(r1)
ffc05094: 83 61 00 0c lwz r27,12(r1)
ffc05098: 7c 08 03 a6 mtlr r0
ffc0509c: 83 81 00 10 lwz r28,16(r1)
ffc050a0: 83 a1 00 14 lwz r29,20(r1)
ffc050a4: 83 c1 00 18 lwz r30,24(r1)
ffc050a8: 83 e1 00 1c lwz r31,28(r1)
ffc050ac: 38 21 00 20 addi r1,r1,32
ffc050b0: 4e 80 00 20 blr
ffc04ed4 <rtems_disk_io_initialize>:
}
}
rtems_status_code
rtems_disk_io_initialize(void)
{
ffc04ed4: 94 21 ff e8 stwu r1,-24(r1)
ffc04ed8: 7c 08 02 a6 mflr r0
ffc04edc: 93 e1 00 14 stw r31,20(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number size = DISKTAB_INITIAL_SIZE;
if (disktab_size > 0) {
ffc04ee0: 3f e0 00 00 lis r31,0
}
}
rtems_status_code
rtems_disk_io_initialize(void)
{
ffc04ee4: 93 a1 00 0c stw r29,12(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number size = DISKTAB_INITIAL_SIZE;
if (disktab_size > 0) {
ffc04ee8: 83 bf 28 e8 lwz r29,10472(r31)
}
}
rtems_status_code
rtems_disk_io_initialize(void)
{
ffc04eec: 93 81 00 08 stw r28,8(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number size = DISKTAB_INITIAL_SIZE;
if (disktab_size > 0) {
ffc04ef0: 3b 9f 28 e8 addi r28,r31,10472
ffc04ef4: 2f 9d 00 00 cmpwi cr7,r29,0
}
}
rtems_status_code
rtems_disk_io_initialize(void)
{
ffc04ef8: 93 c1 00 10 stw r30,16(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number size = DISKTAB_INITIAL_SIZE;
if (disktab_size > 0) {
return RTEMS_SUCCESSFUL;
ffc04efc: 3b c0 00 00 li r30,0
}
}
rtems_status_code
rtems_disk_io_initialize(void)
{
ffc04f00: 90 01 00 1c stw r0,28(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number size = DISKTAB_INITIAL_SIZE;
if (disktab_size > 0) {
ffc04f04: 41 9e 00 28 beq- cr7,ffc04f2c <rtems_disk_io_initialize+0x58><== ALWAYS TAKEN
}
disktab_size = size;
return RTEMS_SUCCESSFUL;
}
ffc04f08: 80 01 00 1c lwz r0,28(r1)
ffc04f0c: 7f c3 f3 78 mr r3,r30
ffc04f10: 83 81 00 08 lwz r28,8(r1)
ffc04f14: 7c 08 03 a6 mtlr r0
ffc04f18: 83 a1 00 0c lwz r29,12(r1)
ffc04f1c: 83 c1 00 10 lwz r30,16(r1)
ffc04f20: 83 e1 00 14 lwz r31,20(r1)
ffc04f24: 38 21 00 18 addi r1,r1,24
ffc04f28: 4e 80 00 20 blr
if (disktab_size > 0) {
return RTEMS_SUCCESSFUL;
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
ffc04f2c: 38 60 00 08 li r3,8
ffc04f30: 38 80 00 08 li r4,8
ffc04f34: 48 00 0b 3d bl ffc05a70 <calloc>
if (disktab == NULL) {
return RTEMS_NO_MEMORY;
ffc04f38: 3b c0 00 1a li r30,26
if (disktab_size > 0) {
return RTEMS_SUCCESSFUL;
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
if (disktab == NULL) {
ffc04f3c: 2f 83 00 00 cmpwi cr7,r3,0
if (disktab_size > 0) {
return RTEMS_SUCCESSFUL;
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
ffc04f40: 90 7c 00 04 stw r3,4(r28)
if (disktab == NULL) {
ffc04f44: 41 be ff c4 beq- cr7,ffc04f08 <rtems_disk_io_initialize+0x34><== NEVER TAKEN
return RTEMS_NO_MEMORY;
}
diskdevs_protected = false;
sc = rtems_semaphore_create(
ffc04f48: 3c 60 44 44 lis r3,17476
disktab = calloc(size, sizeof(rtems_disk_device_table));
if (disktab == NULL) {
return RTEMS_NO_MEMORY;
}
diskdevs_protected = false;
ffc04f4c: 9b bc 00 0c stb r29,12(r28)
sc = rtems_semaphore_create(
ffc04f50: 60 63 45 56 ori r3,r3,17750
ffc04f54: 38 80 00 01 li r4,1
ffc04f58: 38 a0 00 10 li r5,16
ffc04f5c: 38 c0 00 00 li r6,0
ffc04f60: 38 fc 00 08 addi r7,r28,8
ffc04f64: 48 00 4f 59 bl ffc09ebc <rtems_semaphore_create>
RTEMS_FIFO | RTEMS_BINARY_SEMAPHORE | RTEMS_NO_INHERIT_PRIORITY
| RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL,
0,
&diskdevs_mutex
);
if (sc != RTEMS_SUCCESSFUL) {
ffc04f68: 2f 83 00 00 cmpwi cr7,r3,0
ffc04f6c: 41 9e 00 30 beq- cr7,ffc04f9c <rtems_disk_io_initialize+0xc8><== ALWAYS TAKEN
free(disktab);
ffc04f70: 80 7c 00 04 lwz r3,4(r28) <== NOT EXECUTED
ffc04f74: 48 00 0d a9 bl ffc05d1c <free> <== NOT EXECUTED
}
disktab_size = size;
return RTEMS_SUCCESSFUL;
}
ffc04f78: 80 01 00 1c lwz r0,28(r1) <== NOT EXECUTED
ffc04f7c: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc04f80: 83 81 00 08 lwz r28,8(r1) <== NOT EXECUTED
ffc04f84: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc04f88: 83 a1 00 0c lwz r29,12(r1) <== NOT EXECUTED
ffc04f8c: 83 c1 00 10 lwz r30,16(r1) <== NOT EXECUTED
ffc04f90: 83 e1 00 14 lwz r31,20(r1) <== NOT EXECUTED
ffc04f94: 38 21 00 18 addi r1,r1,24 <== NOT EXECUTED
ffc04f98: 4e 80 00 20 blr <== NOT EXECUTED
free(disktab);
return RTEMS_NO_MEMORY;
}
sc = rtems_bdbuf_init();
ffc04f9c: 48 00 c0 25 bl ffc10fc0 <rtems_bdbuf_init>
if (sc != RTEMS_SUCCESSFUL) {
ffc04fa0: 2f 83 00 00 cmpwi cr7,r3,0
ffc04fa4: 40 9e 00 14 bne- cr7,ffc04fb8 <rtems_disk_io_initialize+0xe4><== NEVER TAKEN
free(disktab);
return RTEMS_UNSATISFIED;
}
disktab_size = size;
ffc04fa8: 38 00 00 08 li r0,8
ffc04fac: 90 1f 28 e8 stw r0,10472(r31)
return RTEMS_SUCCESSFUL;
ffc04fb0: 3b c0 00 00 li r30,0
ffc04fb4: 4b ff ff 54 b ffc04f08 <rtems_disk_io_initialize+0x34>
return RTEMS_NO_MEMORY;
}
sc = rtems_bdbuf_init();
if (sc != RTEMS_SUCCESSFUL) {
rtems_semaphore_delete(diskdevs_mutex);
ffc04fb8: 80 7c 00 08 lwz r3,8(r28) <== NOT EXECUTED
free(disktab);
return RTEMS_UNSATISFIED;
ffc04fbc: 3b c0 00 0d li r30,13 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
sc = rtems_bdbuf_init();
if (sc != RTEMS_SUCCESSFUL) {
rtems_semaphore_delete(diskdevs_mutex);
ffc04fc0: 48 00 50 f9 bl ffc0a0b8 <rtems_semaphore_delete> <== NOT EXECUTED
free(disktab);
ffc04fc4: 80 7c 00 04 lwz r3,4(r28) <== NOT EXECUTED
ffc04fc8: 48 00 0d 55 bl ffc05d1c <free> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
ffc04fcc: 4b ff ff 3c b ffc04f08 <rtems_disk_io_initialize+0x34><== NOT EXECUTED
ffc04d80 <rtems_disk_next>:
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device_table *dtab = NULL;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
if (dev != (dev_t) -1) {
ffc04d80: 2f 83 ff ff cmpwi cr7,r3,-1
return RTEMS_SUCCESSFUL;
}
rtems_disk_device *
rtems_disk_next(dev_t dev)
{
ffc04d84: 94 21 ff e0 stwu r1,-32(r1)
ffc04d88: 7c 08 02 a6 mflr r0
ffc04d8c: 93 81 00 10 stw r28,16(r1)
ffc04d90: 90 01 00 24 stw r0,36(r1)
ffc04d94: 93 a1 00 14 stw r29,20(r1)
ffc04d98: 93 c1 00 18 stw r30,24(r1)
ffc04d9c: 93 e1 00 1c stw r31,28(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device_table *dtab = NULL;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
if (dev != (dev_t) -1) {
ffc04da0: 41 9e 01 10 beq- cr7,ffc04eb0 <rtems_disk_next+0x130>
rtems_filesystem_split_dev_t(dev, major, minor);
/* If minor wraps around */
if ((minor + 1) < minor) {
ffc04da4: 3b e4 00 01 addi r31,r4,1
ffc04da8: 7f 9f 20 40 cmplw cr7,r31,r4
)
{
union __rtems_dev_t temp;
temp.device = device;
return temp.__overlay.major;
ffc04dac: 7c 7e 1b 78 mr r30,r3
ffc04db0: 41 9c 00 bc blt- cr7,ffc04e6c <rtems_disk_next+0xec> <== NEVER TAKEN
} else {
++minor;
}
}
sc = disk_lock();
ffc04db4: 4b ff f6 a5 bl ffc04458 <disk_lock>
if (sc != RTEMS_SUCCESSFUL) {
ffc04db8: 2f 83 00 00 cmpwi cr7,r3,0
return NULL;
ffc04dbc: 38 60 00 00 li r3,0
++minor;
}
}
sc = disk_lock();
if (sc != RTEMS_SUCCESSFUL) {
ffc04dc0: 40 9e 00 68 bne- cr7,ffc04e28 <rtems_disk_next+0xa8> <== NEVER TAKEN
return NULL;
}
if (major >= disktab_size) {
ffc04dc4: 3d 20 00 00 lis r9,0
ffc04dc8: 81 09 28 e8 lwz r8,10472(r9)
ffc04dcc: 39 29 28 e8 addi r9,r9,10472
ffc04dd0: 7f 9e 40 40 cmplw cr7,r30,r8
ffc04dd4: 40 9c 00 f0 bge- cr7,ffc04ec4 <rtems_disk_next+0x144> <== NEVER TAKEN
disk_unlock();
return NULL;
}
dtab = disktab + major;
ffc04dd8: 81 69 00 04 lwz r11,4(r9)
ffc04ddc: 57 dd 18 38 rlwinm r29,r30,3,0,28
ffc04de0: 7d 2b e8 2e lwzx r9,r11,r29
ffc04de4: 7f ab ea 14 add r29,r11,r29
ffc04de8: 2f 09 00 00 cmpwi cr6,r9,0
disk_unlock();
return NULL;
}
dtab = disktab + major;
} else if (dtab->minor [minor] == NULL) {
ffc04dec: 57 fc 10 3a rlwinm r28,r31,2,0,29
return NULL;
}
dtab = disktab + major;
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
ffc04df0: 41 9a 00 58 beq- cr6,ffc04e48 <rtems_disk_next+0xc8>
ffc04df4: 80 1d 00 04 lwz r0,4(r29)
ffc04df8: 7f 9f 00 40 cmplw cr7,r31,r0
return NULL;
}
dtab = disktab + major;
} else if (dtab->minor [minor] == NULL) {
++minor;
ffc04dfc: 3b ff 00 01 addi r31,r31,1
return NULL;
}
dtab = disktab + major;
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
ffc04e00: 40 9c 00 48 bge- cr7,ffc04e48 <rtems_disk_next+0xc8>
disk_unlock();
return NULL;
}
dtab = disktab + major;
} else if (dtab->minor [minor] == NULL) {
ffc04e04: 7d 49 e0 2e lwzx r10,r9,r28
ffc04e08: 2f 8a 00 00 cmpwi cr7,r10,0
ffc04e0c: 41 9e ff e0 beq+ cr7,ffc04dec <rtems_disk_next+0x6c>
++minor;
} else {
++dtab->minor [minor]->uses;
ffc04e10: 81 2a 00 14 lwz r9,20(r10)
ffc04e14: 38 09 00 01 addi r0,r9,1
ffc04e18: 90 0a 00 14 stw r0,20(r10)
disk_unlock();
ffc04e1c: 4b ff f6 a5 bl ffc044c0 <disk_unlock>
return dtab->minor [minor];
ffc04e20: 81 3d 00 00 lwz r9,0(r29)
ffc04e24: 7c 69 e0 2e lwzx r3,r9,r28
}
}
}
ffc04e28: 80 01 00 24 lwz r0,36(r1)
ffc04e2c: 83 81 00 10 lwz r28,16(r1)
ffc04e30: 7c 08 03 a6 mtlr r0
ffc04e34: 83 a1 00 14 lwz r29,20(r1)
ffc04e38: 83 c1 00 18 lwz r30,24(r1)
ffc04e3c: 83 e1 00 1c lwz r31,28(r1)
ffc04e40: 38 21 00 20 addi r1,r1,32
ffc04e44: 4e 80 00 20 blr
dtab = disktab + major;
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
minor = 0;
++major;
ffc04e48: 3b de 00 01 addi r30,r30,1
if (major >= disktab_size) {
ffc04e4c: 7f 88 f0 40 cmplw cr7,r8,r30
disk_unlock();
return NULL;
}
dtab = disktab + major;
ffc04e50: 57 c0 18 38 rlwinm r0,r30,3,0,28
ffc04e54: 7f ab 02 14 add r29,r11,r0
}
dtab = disktab + major;
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
minor = 0;
ffc04e58: 3b e0 00 00 li r31,0
++major;
if (major >= disktab_size) {
ffc04e5c: 40 9d 00 2c ble- cr7,ffc04e88 <rtems_disk_next+0x108>
disk_unlock();
return NULL;
}
dtab = disktab + major;
ffc04e60: 7d 2b 00 2e lwzx r9,r11,r0
ffc04e64: 2f 09 00 00 cmpwi cr6,r9,0
ffc04e68: 4b ff ff 84 b ffc04dec <rtems_disk_next+0x6c>
rtems_filesystem_split_dev_t(dev, major, minor);
/* If minor wraps around */
if ((minor + 1) < minor) {
/* If major wraps around */
if ((major + 1) < major) {
ffc04e6c: 38 03 00 01 addi r0,r3,1 <== NOT EXECUTED
ffc04e70: 7f 80 18 40 cmplw cr7,r0,r3 <== NOT EXECUTED
return NULL;
ffc04e74: 38 60 00 00 li r3,0 <== NOT EXECUTED
rtems_filesystem_split_dev_t(dev, major, minor);
/* If minor wraps around */
if ((minor + 1) < minor) {
/* If major wraps around */
if ((major + 1) < major) {
ffc04e78: 41 bc ff b0 blt- cr7,ffc04e28 <rtems_disk_next+0xa8> <== NOT EXECUTED
ffc04e7c: 7c 1e 03 78 mr r30,r0 <== NOT EXECUTED
return NULL;
}
++major;
minor = 0;
ffc04e80: 3b e0 00 00 li r31,0 <== NOT EXECUTED
ffc04e84: 4b ff ff 30 b ffc04db4 <rtems_disk_next+0x34> <== NOT EXECUTED
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
minor = 0;
++major;
if (major >= disktab_size) {
disk_unlock();
ffc04e88: 4b ff f6 39 bl ffc044c0 <disk_unlock>
disk_unlock();
return dtab->minor [minor];
}
}
}
ffc04e8c: 80 01 00 24 lwz r0,36(r1)
minor = 0;
++major;
if (major >= disktab_size) {
disk_unlock();
return NULL;
ffc04e90: 38 60 00 00 li r3,0
disk_unlock();
return dtab->minor [minor];
}
}
}
ffc04e94: 83 81 00 10 lwz r28,16(r1)
ffc04e98: 7c 08 03 a6 mtlr r0
ffc04e9c: 83 a1 00 14 lwz r29,20(r1)
ffc04ea0: 83 c1 00 18 lwz r30,24(r1)
ffc04ea4: 83 e1 00 1c lwz r31,28(r1)
ffc04ea8: 38 21 00 20 addi r1,r1,32
ffc04eac: 4e 80 00 20 blr
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device_table *dtab = NULL;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
if (dev != (dev_t) -1) {
ffc04eb0: 2f 84 ff ff cmpwi cr7,r4,-1
ffc04eb4: 40 9e fe f0 bne+ cr7,ffc04da4 <rtems_disk_next+0x24> <== NEVER TAKEN
rtems_disk_next(dev_t dev)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device_table *dtab = NULL;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
ffc04eb8: 3b e0 00 00 li r31,0
rtems_disk_device *
rtems_disk_next(dev_t dev)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device_table *dtab = NULL;
rtems_device_major_number major = 0;
ffc04ebc: 3b c0 00 00 li r30,0
ffc04ec0: 4b ff fe f4 b ffc04db4 <rtems_disk_next+0x34>
if (sc != RTEMS_SUCCESSFUL) {
return NULL;
}
if (major >= disktab_size) {
disk_unlock();
ffc04ec4: 90 61 00 08 stw r3,8(r1) <== NOT EXECUTED
ffc04ec8: 4b ff f5 f9 bl ffc044c0 <disk_unlock> <== NOT EXECUTED
return NULL;
ffc04ecc: 80 61 00 08 lwz r3,8(r1) <== NOT EXECUTED
ffc04ed0: 4b ff ff 58 b ffc04e28 <rtems_disk_next+0xa8> <== NOT EXECUTED
ffc04c50 <rtems_disk_obtain>:
return RTEMS_SUCCESSFUL;
}
rtems_disk_device *
rtems_disk_obtain(dev_t dev)
{
ffc04c50: 94 21 ff e0 stwu r1,-32(r1)
ffc04c54: 7c 08 02 a6 mflr r0
ffc04c58: 93 81 00 10 stw r28,16(r1)
ffc04c5c: 7c 7c 1b 78 mr r28,r3
ffc04c60: 93 a1 00 14 stw r29,20(r1)
ffc04c64: 7c 9d 23 78 mr r29,r4
ffc04c68: 90 01 00 24 stw r0,36(r1)
ffc04c6c: 93 e1 00 1c stw r31,28(r1)
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc04c70: 7f e0 00 a6 mfmsr r31
ffc04c74: 7c 10 42 a6 mfsprg r0,0
ffc04c78: 7f e0 00 78 andc r0,r31,r0
ffc04c7c: 7c 00 01 24 mtmsr r0
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
rtems_interrupt_level level;
rtems_interrupt_disable(level);
if (!diskdevs_protected) {
ffc04c80: 3d 20 00 00 lis r9,0
ffc04c84: 88 09 28 f4 lbz r0,10484(r9)
ffc04c88: 2f 80 00 00 cmpwi cr7,r0,0
ffc04c8c: 41 9e 00 50 beq- cr7,ffc04cdc <rtems_disk_obtain+0x8c> <== ALWAYS TAKEN
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc04c90: 7f e0 01 24 mtmsr r31 <== NOT EXECUTED
dd = get_disk_entry(dev, false);
rtems_interrupt_enable(level);
} else {
rtems_interrupt_enable(level);
sc = disk_lock();
ffc04c94: 4b ff f7 c5 bl ffc04458 <disk_lock> <== NOT EXECUTED
if (sc == RTEMS_SUCCESSFUL) {
ffc04c98: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
rtems_disk_device *
rtems_disk_obtain(dev_t dev)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
ffc04c9c: 38 60 00 00 li r3,0 <== NOT EXECUTED
rtems_interrupt_enable(level);
} else {
rtems_interrupt_enable(level);
sc = disk_lock();
if (sc == RTEMS_SUCCESSFUL) {
ffc04ca0: 40 9e 00 20 bne- cr7,ffc04cc0 <rtems_disk_obtain+0x70> <== NOT EXECUTED
dd = get_disk_entry(dev, false);
ffc04ca4: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc04ca8: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc04cac: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc04cb0: 4b ff f6 b1 bl ffc04360 <get_disk_entry> <== NOT EXECUTED
disk_unlock();
ffc04cb4: 90 61 00 08 stw r3,8(r1) <== NOT EXECUTED
ffc04cb8: 4b ff f8 09 bl ffc044c0 <disk_unlock> <== NOT EXECUTED
ffc04cbc: 80 61 00 08 lwz r3,8(r1) <== NOT EXECUTED
}
}
return dd;
}
ffc04cc0: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
ffc04cc4: 83 81 00 10 lwz r28,16(r1) <== NOT EXECUTED
ffc04cc8: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc04ccc: 83 a1 00 14 lwz r29,20(r1) <== NOT EXECUTED
ffc04cd0: 83 e1 00 1c lwz r31,28(r1) <== NOT EXECUTED
ffc04cd4: 38 21 00 20 addi r1,r1,32 <== NOT EXECUTED
ffc04cd8: 4e 80 00 20 blr <== NOT EXECUTED
rtems_interrupt_level level;
rtems_interrupt_disable(level);
if (!diskdevs_protected) {
/* Frequent and quickest case */
dd = get_disk_entry(dev, false);
ffc04cdc: 38 a0 00 00 li r5,0
ffc04ce0: 4b ff f6 81 bl ffc04360 <get_disk_entry>
ffc04ce4: 7f e0 01 24 mtmsr r31
disk_unlock();
}
}
return dd;
}
ffc04ce8: 80 01 00 24 lwz r0,36(r1)
ffc04cec: 83 81 00 10 lwz r28,16(r1)
ffc04cf0: 7c 08 03 a6 mtlr r0
ffc04cf4: 83 a1 00 14 lwz r29,20(r1)
ffc04cf8: 83 e1 00 1c lwz r31,28(r1)
ffc04cfc: 38 21 00 20 addi r1,r1,32
ffc04d00: 4e 80 00 20 blr
ffc04df4 <rtems_error>:
int rtems_error(
rtems_error_code_t error_flag,
const char *printf_format,
...
)
{
ffc04df4: 94 21 ff 88 stwu r1,-120(r1)
ffc04df8: 7c 08 02 a6 mflr r0
ffc04dfc: 93 e1 00 74 stw r31,116(r1)
ffc04e00: 7c 7f 1b 78 mr r31,r3
ffc04e04: 90 01 00 7c stw r0,124(r1)
ffc04e08: 90 a1 00 18 stw r5,24(r1)
ffc04e0c: 90 c1 00 1c stw r6,28(r1)
ffc04e10: 90 e1 00 20 stw r7,32(r1)
ffc04e14: 91 01 00 24 stw r8,36(r1)
ffc04e18: 91 21 00 28 stw r9,40(r1)
ffc04e1c: 91 41 00 2c stw r10,44(r1)
ffc04e20: 40 86 00 24 bne- cr1,ffc04e44 <rtems_error+0x50> <== ALWAYS TAKEN
ffc04e24: d8 21 00 30 stfd f1,48(r1) <== NOT EXECUTED
ffc04e28: d8 41 00 38 stfd f2,56(r1) <== NOT EXECUTED
ffc04e2c: d8 61 00 40 stfd f3,64(r1) <== NOT EXECUTED
ffc04e30: d8 81 00 48 stfd f4,72(r1) <== NOT EXECUTED
ffc04e34: d8 a1 00 50 stfd f5,80(r1) <== NOT EXECUTED
ffc04e38: d8 c1 00 58 stfd f6,88(r1) <== NOT EXECUTED
ffc04e3c: d8 e1 00 60 stfd f7,96(r1) <== NOT EXECUTED
ffc04e40: d9 01 00 68 stfd f8,104(r1) <== NOT EXECUTED
va_list arglist;
int chars_written;
va_start(arglist, printf_format);
ffc04e44: 38 00 00 02 li r0,2
ffc04e48: 98 01 00 08 stb r0,8(r1)
ffc04e4c: 38 00 00 00 li r0,0
chars_written = rtems_verror(error_flag, printf_format, arglist);
ffc04e50: 7f e3 fb 78 mr r3,r31
)
{
va_list arglist;
int chars_written;
va_start(arglist, printf_format);
ffc04e54: 98 01 00 09 stb r0,9(r1)
ffc04e58: 38 01 00 80 addi r0,r1,128
chars_written = rtems_verror(error_flag, printf_format, arglist);
ffc04e5c: 38 a1 00 08 addi r5,r1,8
)
{
va_list arglist;
int chars_written;
va_start(arglist, printf_format);
ffc04e60: 90 01 00 0c stw r0,12(r1)
ffc04e64: 38 01 00 10 addi r0,r1,16
ffc04e68: 90 01 00 10 stw r0,16(r1)
chars_written = rtems_verror(error_flag, printf_format, arglist);
ffc04e6c: 4b ff fd d1 bl ffc04c3c <rtems_verror>
va_end(arglist);
if (error_flag & RTEMS_ERROR_PANIC) {
ffc04e70: 77 e0 20 00 andis. r0,r31,8192
ffc04e74: 40 82 00 20 bne- ffc04e94 <rtems_error+0xa0>
rtems_error(0, "fatal error, exiting");
_exit(errno);
}
if (error_flag & RTEMS_ERROR_ABORT) {
ffc04e78: 77 e0 10 00 andis. r0,r31,4096
ffc04e7c: 40 82 00 38 bne- ffc04eb4 <rtems_error+0xc0>
rtems_error(0, "fatal error, aborting");
abort();
}
return chars_written;
}
ffc04e80: 80 01 00 7c lwz r0,124(r1)
ffc04e84: 83 e1 00 74 lwz r31,116(r1)
ffc04e88: 38 21 00 78 addi r1,r1,120
ffc04e8c: 7c 08 03 a6 mtlr r0
ffc04e90: 4e 80 00 20 blr
va_start(arglist, printf_format);
chars_written = rtems_verror(error_flag, printf_format, arglist);
va_end(arglist);
if (error_flag & RTEMS_ERROR_PANIC) {
rtems_error(0, "fatal error, exiting");
ffc04e94: 3c 80 ff c2 lis r4,-62
ffc04e98: 38 84 08 a8 addi r4,r4,2216
ffc04e9c: 38 60 00 00 li r3,0
ffc04ea0: 4c c6 31 82 crclr 4*cr1+eq
ffc04ea4: 4b ff ff 51 bl ffc04df4 <rtems_error>
_exit(errno);
ffc04ea8: 48 00 ee e5 bl ffc13d8c <__errno>
ffc04eac: 80 63 00 00 lwz r3,0(r3)
ffc04eb0: 48 00 0e 59 bl ffc05d08 <_exit>
}
if (error_flag & RTEMS_ERROR_ABORT) {
rtems_error(0, "fatal error, aborting");
ffc04eb4: 3c 80 ff c2 lis r4,-62
ffc04eb8: 38 84 08 c0 addi r4,r4,2240
ffc04ebc: 38 60 00 00 li r3,0
ffc04ec0: 4c c6 31 82 crclr 4*cr1+eq
ffc04ec4: 4b ff ff 31 bl ffc04df4 <rtems_error>
abort();
ffc04ec8: 48 00 ee a9 bl ffc13d70 <abort>
ffc0fa64 <rtems_filesystem_get_mount_handler>:
find_arg fa = {
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
ffc0fa64: 2f 83 00 00 cmpwi cr7,r3,0
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
ffc0fa68: 94 21 ff e8 stwu r1,-24(r1)
ffc0fa6c: 7c 08 02 a6 mflr r0
find_arg fa = {
ffc0fa70: 90 61 00 08 stw r3,8(r1)
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
ffc0fa74: 38 60 00 00 li r3,0
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
ffc0fa78: 90 01 00 1c stw r0,28(r1)
find_arg fa = {
ffc0fa7c: 38 00 00 00 li r0,0
ffc0fa80: 90 01 00 0c stw r0,12(r1)
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
ffc0fa84: 41 9e 00 18 beq- cr7,ffc0fa9c <rtems_filesystem_get_mount_handler+0x38><== NEVER TAKEN
rtems_filesystem_iterate( find_handler, &fa );
ffc0fa88: 3c 60 ff c1 lis r3,-63
ffc0fa8c: 38 63 f8 f8 addi r3,r3,-1800
ffc0fa90: 38 81 00 08 addi r4,r1,8
ffc0fa94: 4b ff fe bd bl ffc0f950 <rtems_filesystem_iterate>
ffc0fa98: 80 61 00 0c lwz r3,12(r1)
}
return fa.mount_h;
}
ffc0fa9c: 80 01 00 1c lwz r0,28(r1)
ffc0faa0: 38 21 00 18 addi r1,r1,24
ffc0faa4: 7c 08 03 a6 mtlr r0
ffc0faa8: 4e 80 00 20 blr
ffc04a4c <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 )
{
ffc04a4c: 94 21 ff d0 stwu r1,-48(r1)
ffc04a50: 7c 08 02 a6 mflr r0
rtems_filesystem_umask = 022;
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
ffc04a54: 3d 20 00 00 lis r9,0
* configuration is a single instantiation of the IMFS or miniIMFS with
* a single "/dev" directory in it.
*/
void rtems_filesystem_initialize( void )
{
ffc04a58: 90 01 00 34 stw r0,52(r1)
rtems_filesystem_umask = 022;
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
ffc04a5c: 80 09 27 30 lwz r0,10032(r9)
* configuration is a single instantiation of the IMFS or miniIMFS with
* a single "/dev" directory in it.
*/
void rtems_filesystem_initialize( void )
{
ffc04a60: 93 e1 00 2c stw r31,44(r1)
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
ffc04a64: 3f e0 00 00 lis r31,0
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
ffc04a68: 2f 80 00 00 cmpwi cr7,r0,0
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
ffc04a6c: 81 3f 27 7c lwz r9,10108(r31)
ffc04a70: 38 00 00 12 li r0,18
* configuration is a single instantiation of the IMFS or miniIMFS with
* a single "/dev" directory in it.
*/
void rtems_filesystem_initialize( void )
{
ffc04a74: 93 c1 00 28 stw r30,40(r1)
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
ffc04a78: 90 09 00 2c stw r0,44(r9)
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
ffc04a7c: 41 9e 00 f8 beq- cr7,ffc04b74 <rtems_filesystem_initialize+0x128><== NEVER TAKEN
rtems_fatal_error_occurred( 0xABCD0001 );
mt = &rtems_filesystem_mount_table[0];
ffc04a80: 3d 20 00 00 lis r9,0
ffc04a84: 81 29 27 34 lwz r9,10036(r9)
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
ffc04a88: 38 e0 00 00 li r7,0
ffc04a8c: 80 69 00 08 lwz r3,8(r9)
ffc04a90: 80 89 00 0c lwz r4,12(r9)
ffc04a94: 80 a9 00 00 lwz r5,0(r9)
ffc04a98: 80 c9 00 04 lwz r6,4(r9)
ffc04a9c: 48 00 0e 51 bl ffc058ec <mount>
if ( status == -1 )
ffc04aa0: 2f 83 ff ff cmpwi cr7,r3,-1
ffc04aa4: 41 9e 00 e8 beq- cr7,ffc04b8c <rtems_filesystem_initialize+0x140><== NEVER TAKEN
rtems_fatal_error_occurred( 0xABCD0002 );
rtems_filesystem_link_counts = 0;
ffc04aa8: 81 3f 27 7c lwz r9,10108(r31)
ffc04aac: 38 00 00 00 li r0,0
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
ffc04ab0: 3f c0 ff c2 lis r30,-62
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;
ffc04ab4: b0 09 00 30 sth r0,48(r9)
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
ffc04ab8: 3b de 07 00 addi r30,r30,1792
ffc04abc: 38 80 00 01 li r4,1
ffc04ac0: 38 a0 00 00 li r5,0
ffc04ac4: 38 c1 00 08 addi r6,r1,8
ffc04ac8: 38 e0 00 00 li r7,0
ffc04acc: 7f c3 f3 78 mr r3,r30
ffc04ad0: 48 00 05 45 bl ffc05014 <rtems_filesystem_evaluate_path>
rtems_filesystem_root = loc;
ffc04ad4: 81 3f 27 7c lwz r9,10108(r31)
ffc04ad8: 80 01 00 08 lwz r0,8(r1)
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
ffc04adc: 38 80 00 01 li r4,1
ffc04ae0: 38 a0 00 00 li r5,0
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
rtems_filesystem_root = loc;
ffc04ae4: 90 09 00 18 stw r0,24(r9)
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
ffc04ae8: 38 c1 00 08 addi r6,r1,8
ffc04aec: 38 e0 00 00 li r7,0
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
rtems_filesystem_root = loc;
ffc04af0: 80 01 00 0c lwz r0,12(r1)
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
ffc04af4: 7f c3 f3 78 mr r3,r30
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
rtems_filesystem_root = loc;
ffc04af8: 90 09 00 1c stw r0,28(r9)
ffc04afc: 80 01 00 10 lwz r0,16(r1)
ffc04b00: 90 09 00 20 stw r0,32(r9)
ffc04b04: 80 01 00 14 lwz r0,20(r1)
ffc04b08: 90 09 00 24 stw r0,36(r9)
ffc04b0c: 80 01 00 18 lwz r0,24(r1)
ffc04b10: 90 09 00 28 stw r0,40(r9)
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
ffc04b14: 48 00 05 01 bl ffc05014 <rtems_filesystem_evaluate_path>
rtems_filesystem_current = loc;
ffc04b18: 81 3f 27 7c lwz r9,10108(r31)
ffc04b1c: 80 01 00 08 lwz r0,8(r1)
*
* 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);
ffc04b20: 3c 60 ff c2 lis r3,-62
ffc04b24: 38 63 07 04 addi r3,r3,1796
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
rtems_filesystem_root = loc;
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
rtems_filesystem_current = loc;
ffc04b28: 90 09 00 04 stw r0,4(r9)
*
* 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);
ffc04b2c: 38 80 01 ff li r4,511
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
rtems_filesystem_root = loc;
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
rtems_filesystem_current = loc;
ffc04b30: 80 01 00 0c lwz r0,12(r1)
ffc04b34: 90 09 00 08 stw r0,8(r9)
ffc04b38: 80 01 00 10 lwz r0,16(r1)
ffc04b3c: 90 09 00 0c stw r0,12(r9)
ffc04b40: 80 01 00 14 lwz r0,20(r1)
ffc04b44: 90 09 00 10 stw r0,16(r9)
ffc04b48: 80 01 00 18 lwz r0,24(r1)
ffc04b4c: 90 09 00 14 stw r0,20(r9)
*
* 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);
ffc04b50: 48 00 0b 9d bl ffc056ec <mkdir>
if ( status != 0 )
ffc04b54: 2f 83 00 00 cmpwi cr7,r3,0
ffc04b58: 40 9e 00 28 bne- cr7,ffc04b80 <rtems_filesystem_initialize+0x134><== 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.
*/
}
ffc04b5c: 80 01 00 34 lwz r0,52(r1)
ffc04b60: 83 c1 00 28 lwz r30,40(r1)
ffc04b64: 7c 08 03 a6 mtlr r0
ffc04b68: 83 e1 00 2c lwz r31,44(r1)
ffc04b6c: 38 21 00 30 addi r1,r1,48
ffc04b70: 4e 80 00 20 blr
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
rtems_fatal_error_occurred( 0xABCD0001 );
ffc04b74: 3c 60 ab cd lis r3,-21555 <== NOT EXECUTED
ffc04b78: 60 63 00 01 ori r3,r3,1 <== NOT EXECUTED
ffc04b7c: 48 00 51 c5 bl ffc09d40 <rtems_fatal_error_occurred> <== NOT EXECUTED
* created that way by the IMFS.
*/
status = mkdir( "/dev", 0777);
if ( status != 0 )
rtems_fatal_error_occurred( 0xABCD0003 );
ffc04b80: 3c 60 ab cd lis r3,-21555 <== NOT EXECUTED
ffc04b84: 60 63 00 03 ori r3,r3,3 <== NOT EXECUTED
ffc04b88: 48 00 51 b9 bl ffc09d40 <rtems_fatal_error_occurred> <== NOT EXECUTED
mt = &rtems_filesystem_mount_table[0];
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
if ( status == -1 )
rtems_fatal_error_occurred( 0xABCD0002 );
ffc04b8c: 3c 60 ab cd lis r3,-21555 <== NOT EXECUTED
ffc04b90: 60 63 00 02 ori r3,r3,2 <== NOT EXECUTED
ffc04b94: 48 00 51 ad bl ffc09d40 <rtems_fatal_error_occurred> <== NOT EXECUTED
ffc0f950 <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
ffc0f950: 94 21 ff d8 stwu r1,-40(r1)
ffc0f954: 7c 08 02 a6 mflr r0
ffc0f958: 93 a1 00 1c stw r29,28(r1)
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
ffc0f95c: 3f a0 ff c2 lis r29,-62
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
ffc0f960: 90 01 00 2c stw r0,44(r1)
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
ffc0f964: 80 1d f9 e8 lwz r0,-1560(r29)
ffc0f968: 3b bd f9 e8 addi r29,r29,-1560
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
ffc0f96c: 93 e1 00 24 stw r31,36(r1)
ffc0f970: 7c 9f 23 78 mr r31,r4
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
ffc0f974: 2f 80 00 00 cmpwi cr7,r0,0
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
ffc0f978: 93 61 00 14 stw r27,20(r1)
ffc0f97c: 93 81 00 18 stw r28,24(r1)
ffc0f980: 93 c1 00 20 stw r30,32(r1)
ffc0f984: 90 61 00 08 stw r3,8(r1)
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
ffc0f988: 41 9e 00 4c beq- cr7,ffc0f9d4 <rtems_filesystem_iterate+0x84><== NEVER TAKEN
ffc0f98c: 7f be eb 78 mr r30,r29
ffc0f990: 3b 9d 00 08 addi r28,r29,8
ffc0f994: 48 00 00 08 b ffc0f99c <rtems_filesystem_iterate+0x4c>
ffc0f998: 40 9a 00 a4 bne- cr6,ffc0fa3c <rtems_filesystem_iterate+0xec>
stop = (*routine)( table_entry, routine_arg );
ffc0f99c: 80 01 00 08 lwz r0,8(r1)
ffc0f9a0: 7f c3 f3 78 mr r3,r30
ffc0f9a4: 7f e4 fb 78 mr r4,r31
ffc0f9a8: 7c 09 03 a6 mtctr r0
ffc0f9ac: 4e 80 04 21 bctrl
rtems_filesystem_table_t entry;
} filesystem_node;
static RTEMS_CHAIN_DEFINE_EMPTY(filesystem_chain);
bool rtems_filesystem_iterate(
ffc0f9b0: 7c 1d f0 50 subf r0,r29,r30
{
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
ffc0f9b4: 7c 1c 00 2e lwzx r0,r28,r0
stop = (*routine)( table_entry, routine_arg );
ffc0f9b8: 7c 7b 1b 78 mr r27,r3
{
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
ffc0f9bc: 2f 03 00 00 cmpwi cr6,r3,0
ffc0f9c0: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f9c4: 3b de 00 08 addi r30,r30,8
ffc0f9c8: 40 9e ff d0 bne+ cr7,ffc0f998 <rtems_filesystem_iterate+0x48>
stop = (*routine)( table_entry, routine_arg );
++table_entry;
}
if ( !stop ) {
ffc0f9cc: 2f 83 00 00 cmpwi cr7,r3,0
ffc0f9d0: 40 9e 00 6c bne- cr7,ffc0fa3c <rtems_filesystem_iterate+0xec>
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 );
ffc0f9d4: 3f c0 00 00 lis r30,0
ffc0f9d8: 80 7e 27 f8 lwz r3,10232(r30)
ffc0f9dc: 38 80 00 00 li r4,0
ffc0f9e0: 38 a0 00 00 li r5,0
ffc0f9e4: 4b ff 99 f5 bl ffc093d8 <rtems_semaphore_obtain>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc0f9e8: 3d 20 00 00 lis r9,0
ffc0f9ec: 3b 89 21 c0 addi r28,r9,8640
ffc0f9f0: 83 a9 21 c0 lwz r29,8640(r9)
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
ffc0f9f4: 3b 9c 00 04 addi r28,r28,4
rtems_libio_lock();
for (
ffc0f9f8: 7f 9d e0 00 cmpw cr7,r29,r28
ffc0f9fc: 3b 60 00 00 li r27,0
ffc0fa00: 40 be 00 0c bne+ cr7,ffc0fa0c <rtems_filesystem_iterate+0xbc>
ffc0fa04: 48 00 00 30 b ffc0fa34 <rtems_filesystem_iterate+0xe4>
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
ffc0fa08: 40 9a 00 2c bne- cr6,ffc0fa34 <rtems_filesystem_iterate+0xe4><== NEVER TAKEN
node = rtems_chain_next( node )
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
ffc0fa0c: 80 01 00 08 lwz r0,8(r1)
ffc0fa10: 38 7d 00 08 addi r3,r29,8
ffc0fa14: 7f e4 fb 78 mr r4,r31
ffc0fa18: 7c 09 03 a6 mtctr r0
ffc0fa1c: 4e 80 04 21 bctrl
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
ffc0fa20: 83 bd 00 00 lwz r29,0(r29)
!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 );
ffc0fa24: 7c 7b 1b 78 mr r27,r3
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
ffc0fa28: 7f 9d e0 00 cmpw cr7,r29,r28
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
ffc0fa2c: 2f 03 00 00 cmpwi cr6,r3,0
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
ffc0fa30: 40 9e ff d8 bne+ cr7,ffc0fa08 <rtems_filesystem_iterate+0xb8>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
ffc0fa34: 80 7e 27 f8 lwz r3,10232(r30)
ffc0fa38: 4b ff 9b 2d bl ffc09564 <rtems_semaphore_release>
}
rtems_libio_unlock();
}
return stop;
}
ffc0fa3c: 80 01 00 2c lwz r0,44(r1)
ffc0fa40: 7f 63 db 78 mr r3,r27
ffc0fa44: 83 81 00 18 lwz r28,24(r1)
ffc0fa48: 7c 08 03 a6 mtlr r0
ffc0fa4c: 83 61 00 14 lwz r27,20(r1)
ffc0fa50: 83 a1 00 1c lwz r29,28(r1)
ffc0fa54: 83 c1 00 20 lwz r30,32(r1)
ffc0fa58: 83 e1 00 24 lwz r31,36(r1)
ffc0fa5c: 38 21 00 28 addi r1,r1,40
ffc0fa60: 4e 80 00 20 blr
ffc05834 <rtems_filesystem_mount_iterate>:
bool rtems_filesystem_mount_iterate(
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
ffc05834: 94 21 ff d8 stwu r1,-40(r1)
ffc05838: 7c 08 02 a6 mflr r0
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 );
ffc0583c: 38 a0 00 00 li r5,0
ffc05840: 93 c1 00 20 stw r30,32(r1)
ffc05844: 3f c0 00 00 lis r30,0
ffc05848: 90 61 00 08 stw r3,8(r1)
ffc0584c: 80 7e 27 f8 lwz r3,10232(r30)
ffc05850: 93 e1 00 24 stw r31,36(r1)
ffc05854: 7c 9f 23 78 mr r31,r4
ffc05858: 38 80 00 00 li r4,0
ffc0585c: 93 61 00 14 stw r27,20(r1)
rtems_chain_node *node = NULL;
bool stop = false;
ffc05860: 3b 60 00 00 li r27,0
bool rtems_filesystem_mount_iterate(
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
ffc05864: 93 81 00 18 stw r28,24(r1)
ffc05868: 93 a1 00 1c stw r29,28(r1)
ffc0586c: 90 01 00 2c stw r0,44(r1)
ffc05870: 48 00 3b 69 bl ffc093d8 <rtems_semaphore_obtain>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc05874: 3d 20 00 00 lis r9,0
ffc05878: 3b 89 21 a4 addi r28,r9,8612
ffc0587c: 83 a9 21 a4 lwz r29,8612(r9)
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
ffc05880: 3b 9c 00 04 addi r28,r28,4
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
ffc05884: 7f 9d e0 00 cmpw cr7,r29,r28
ffc05888: 40 be 00 0c bne+ cr7,ffc05894 <rtems_filesystem_mount_iterate+0x60><== ALWAYS TAKEN
ffc0588c: 48 00 00 30 b ffc058bc <rtems_filesystem_mount_iterate+0x88><== NOT EXECUTED
node = rtems_chain_first( &mount_chain );
!rtems_chain_is_tail( &mount_chain, node ) && !stop;
ffc05890: 40 9a 00 2c bne- cr6,ffc058bc <rtems_filesystem_mount_iterate+0x88><== NEVER TAKEN
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 );
ffc05894: 80 01 00 08 lwz r0,8(r1)
ffc05898: 7f a3 eb 78 mr r3,r29
ffc0589c: 7f e4 fb 78 mr r4,r31
ffc058a0: 7c 09 03 a6 mtctr r0
ffc058a4: 4e 80 04 21 bctrl
}
rtems_libio_unlock();
return stop;
}
ffc058a8: 83 bd 00 00 lwz r29,0(r29)
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 );
ffc058ac: 7c 7b 1b 78 mr r27,r3
{
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
ffc058b0: 7f 9d e0 00 cmpw cr7,r29,r28
node = rtems_chain_first( &mount_chain );
!rtems_chain_is_tail( &mount_chain, node ) && !stop;
ffc058b4: 2f 03 00 00 cmpwi cr6,r3,0
{
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
ffc058b8: 40 9e ff d8 bne+ cr7,ffc05890 <rtems_filesystem_mount_iterate+0x5c>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
ffc058bc: 80 7e 27 f8 lwz r3,10232(r30)
ffc058c0: 48 00 3c a5 bl ffc09564 <rtems_semaphore_release>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
ffc058c4: 80 01 00 2c lwz r0,44(r1)
ffc058c8: 7f 63 db 78 mr r3,r27
ffc058cc: 83 81 00 18 lwz r28,24(r1)
ffc058d0: 7c 08 03 a6 mtlr r0
ffc058d4: 83 61 00 14 lwz r27,20(r1)
ffc058d8: 83 a1 00 1c lwz r29,28(r1)
ffc058dc: 83 c1 00 20 lwz r30,32(r1)
ffc058e0: 83 e1 00 24 lwz r31,36(r1)
ffc058e4: 38 21 00 28 addi r1,r1,40
ffc058e8: 4e 80 00 20 blr
ffc050f0 <rtems_filesystem_prefix_separators>:
int rtems_filesystem_prefix_separators(
const char *pathname,
int pathnamelen
)
{
ffc050f0: 94 21 ff e8 stwu r1,-24(r1)
ffc050f4: 7c 08 02 a6 mflr r0
ffc050f8: 93 a1 00 0c stw r29,12(r1)
ffc050fc: 7c 9d 23 78 mr r29,r4
ffc05100: 93 c1 00 10 stw r30,16(r1)
ffc05104: 7c 7e 1b 78 mr r30,r3
ffc05108: 93 e1 00 14 stw r31,20(r1)
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
ffc0510c: 3b e0 00 00 li r31,0
int rtems_filesystem_prefix_separators(
const char *pathname,
int pathnamelen
)
{
ffc05110: 90 01 00 1c stw r0,28(r1)
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
ffc05114: 88 63 00 00 lbz r3,0(r3)
ffc05118: 2f 83 00 00 cmpwi cr7,r3,0
ffc0511c: 41 9e 00 34 beq- cr7,ffc05150 <rtems_filesystem_prefix_separators+0x60>
ffc05120: 2f 84 00 00 cmpwi cr7,r4,0
ffc05124: 40 be 00 20 bne+ cr7,ffc05144 <rtems_filesystem_prefix_separators+0x54><== ALWAYS TAKEN
ffc05128: 48 00 00 28 b ffc05150 <rtems_filesystem_prefix_separators+0x60><== NOT EXECUTED
ffc0512c: 8c 7e 00 01 lbzu r3,1(r30)
{
pathname++;
pathnamelen--;
stripped++;
ffc05130: 3b ff 00 01 addi r31,r31,1
{
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
ffc05134: 7f 1d f8 00 cmpw cr6,r29,r31
ffc05138: 2f 83 00 00 cmpwi cr7,r3,0
ffc0513c: 41 9e 00 14 beq- cr7,ffc05150 <rtems_filesystem_prefix_separators+0x60>
ffc05140: 41 9a 00 10 beq- cr6,ffc05150 <rtems_filesystem_prefix_separators+0x60><== NEVER TAKEN
ffc05144: 48 00 13 ad bl ffc064f0 <rtems_filesystem_is_separator>
ffc05148: 2f 83 00 00 cmpwi cr7,r3,0
ffc0514c: 40 9e ff e0 bne+ cr7,ffc0512c <rtems_filesystem_prefix_separators+0x3c>
pathname++;
pathnamelen--;
stripped++;
}
return stripped;
}
ffc05150: 80 01 00 1c lwz r0,28(r1)
ffc05154: 7f e3 fb 78 mr r3,r31
ffc05158: 83 a1 00 0c lwz r29,12(r1)
ffc0515c: 7c 08 03 a6 mtlr r0
ffc05160: 83 c1 00 10 lwz r30,16(r1)
ffc05164: 83 e1 00 14 lwz r31,20(r1)
ffc05168: 38 21 00 18 addi r1,r1,24
ffc0516c: 4e 80 00 20 blr
ffc0fbc4 <rtems_filesystem_unregister>:
int
rtems_filesystem_unregister(
const char *type
)
{
ffc0fbc4: 94 21 ff e8 stwu r1,-24(r1)
ffc0fbc8: 7c 08 02 a6 mflr r0
ffc0fbcc: 93 e1 00 14 stw r31,20(r1)
rtems_chain_node *node = NULL;
if ( type == NULL ) {
ffc0fbd0: 7c 7f 1b 79 mr. r31,r3
int
rtems_filesystem_unregister(
const char *type
)
{
ffc0fbd4: 90 01 00 1c stw r0,28(r1)
ffc0fbd8: 93 81 00 08 stw r28,8(r1)
ffc0fbdc: 93 a1 00 0c stw r29,12(r1)
ffc0fbe0: 93 c1 00 10 stw r30,16(r1)
rtems_chain_node *node = NULL;
if ( type == NULL ) {
ffc0fbe4: 41 82 00 c8 beq- ffc0fcac <rtems_filesystem_unregister+0xe8>
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 );
ffc0fbe8: 3f c0 00 00 lis r30,0
ffc0fbec: 80 7e 27 f8 lwz r3,10232(r30)
ffc0fbf0: 38 80 00 00 li r4,0
ffc0fbf4: 38 a0 00 00 li r5,0
ffc0fbf8: 4b ff 97 e1 bl ffc093d8 <rtems_semaphore_obtain>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc0fbfc: 3d 20 00 00 lis r9,0
ffc0fc00: 3b 89 21 c0 addi r28,r9,8640
ffc0fc04: 83 a9 21 c0 lwz r29,8640(r9)
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
ffc0fc08: 3b 9c 00 04 addi r28,r28,4
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_libio_lock();
for (
ffc0fc0c: 7f 9d e0 00 cmpw cr7,r29,r28
ffc0fc10: 40 be 00 14 bne+ cr7,ffc0fc24 <rtems_filesystem_unregister+0x60>
ffc0fc14: 48 00 00 60 b ffc0fc74 <rtems_filesystem_unregister+0xb0>
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
ffc0fc18: 83 bd 00 00 lwz r29,0(r29)
if ( type == NULL ) {
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_libio_lock();
for (
ffc0fc1c: 7f 9d e0 00 cmpw cr7,r29,r28
ffc0fc20: 41 9e 00 54 beq- cr7,ffc0fc74 <rtems_filesystem_unregister+0xb0><== ALWAYS TAKEN
!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 ) {
ffc0fc24: 80 7d 00 08 lwz r3,8(r29)
ffc0fc28: 7f e4 fb 78 mr r4,r31
ffc0fc2c: 48 00 54 b1 bl ffc150dc <strcmp>
ffc0fc30: 2f 83 00 00 cmpwi cr7,r3,0
ffc0fc34: 40 9e ff e4 bne+ cr7,ffc0fc18 <rtems_filesystem_unregister+0x54>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
ffc0fc38: 7f a3 eb 78 mr r3,r29
ffc0fc3c: 4b ff a5 e1 bl ffc0a21c <_Chain_Extract>
rtems_chain_extract( node );
free( fsn );
ffc0fc40: 7f a3 eb 78 mr r3,r29
ffc0fc44: 4b ff 55 59 bl ffc0519c <free>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
ffc0fc48: 80 7e 27 f8 lwz r3,10232(r30)
ffc0fc4c: 4b ff 99 19 bl ffc09564 <rtems_semaphore_release>
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
ffc0fc50: 80 01 00 1c lwz r0,28(r1)
if ( strcmp( fsn->entry.type, type ) == 0 ) {
rtems_chain_extract( node );
free( fsn );
rtems_libio_unlock();
return 0;
ffc0fc54: 38 60 00 00 li r3,0
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
ffc0fc58: 83 81 00 08 lwz r28,8(r1)
ffc0fc5c: 7c 08 03 a6 mtlr r0
ffc0fc60: 83 a1 00 0c lwz r29,12(r1)
ffc0fc64: 83 c1 00 10 lwz r30,16(r1)
ffc0fc68: 83 e1 00 14 lwz r31,20(r1)
ffc0fc6c: 38 21 00 18 addi r1,r1,24
ffc0fc70: 4e 80 00 20 blr
ffc0fc74: 80 7e 27 f8 lwz r3,10232(r30)
ffc0fc78: 4b ff 98 ed bl ffc09564 <rtems_semaphore_release>
return 0;
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
ffc0fc7c: 48 00 41 11 bl ffc13d8c <__errno>
ffc0fc80: 38 00 00 02 li r0,2
ffc0fc84: 90 03 00 00 stw r0,0(r3)
ffc0fc88: 38 60 ff ff li r3,-1
}
ffc0fc8c: 80 01 00 1c lwz r0,28(r1)
ffc0fc90: 83 81 00 08 lwz r28,8(r1)
ffc0fc94: 7c 08 03 a6 mtlr r0
ffc0fc98: 83 a1 00 0c lwz r29,12(r1)
ffc0fc9c: 83 c1 00 10 lwz r30,16(r1)
ffc0fca0: 83 e1 00 14 lwz r31,20(r1)
ffc0fca4: 38 21 00 18 addi r1,r1,24
ffc0fca8: 4e 80 00 20 blr
)
{
rtems_chain_node *node = NULL;
if ( type == NULL ) {
rtems_set_errno_and_return_minus_one( EINVAL );
ffc0fcac: 48 00 40 e1 bl ffc13d8c <__errno>
ffc0fcb0: 38 00 00 16 li r0,22
ffc0fcb4: 90 03 00 00 stw r0,0(r3)
ffc0fcb8: 38 60 ff ff li r3,-1
ffc0fcbc: 4b ff ff d0 b ffc0fc8c <rtems_filesystem_unregister+0xc8>
ffc0585c <rtems_gxx_key_create>:
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
ffc0585c: 94 21 ff e8 stwu r1,-24(r1)
ffc05860: 7c 08 02 a6 mflr r0
ffc05864: 93 a1 00 0c stw r29,12(r1)
ffc05868: 7c 7d 1b 78 mr r29,r3
* 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 ) );
ffc0586c: 38 60 00 08 li r3,8
}
return 0;
}
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
ffc05870: 90 01 00 1c stw r0,28(r1)
ffc05874: 93 c1 00 10 stw r30,16(r1)
ffc05878: 7c 9e 23 78 mr r30,r4
ffc0587c: 93 e1 00 14 stw r31,20(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 ) );
ffc05880: 48 00 05 9d bl ffc05e1c <malloc>
ffc05884: 7c 7f 1b 78 mr r31,r3
*key = new_key;
ffc05888: 90 7d 00 00 stw r3,0(r29)
new_key->val = NULL;
ffc0588c: 38 00 00 00 li r0,0
"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 );
ffc05890: 38 60 00 00 li r3,0
ffc05894: 7f e4 fb 78 mr r4,r31
* deal with the value of the key, as used with the POSIX API.
*/
/* Do not pull your hair, trust me this works. :-) */
__gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
*key = new_key;
new_key->val = NULL;
ffc05898: 90 1f 00 00 stw r0,0(r31)
"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 );
ffc0589c: 7f c5 f3 78 mr r5,r30
*/
/* Do not pull your hair, trust me this works. :-) */
__gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
*key = new_key;
new_key->val = NULL;
new_key->dtor = dtor;
ffc058a0: 93 df 00 04 stw r30,4(r31)
"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 );
ffc058a4: 48 00 4b d5 bl ffc0a478 <rtems_task_variable_add>
if ( status == RTEMS_SUCCESSFUL )
ffc058a8: 2f 83 00 00 cmpwi cr7,r3,0
return 0;
ffc058ac: 38 60 00 00 li r3,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 )
ffc058b0: 40 9e 00 20 bne- cr7,ffc058d0 <rtems_gxx_key_create+0x74><== NEVER TAKEN
return 0;
free( new_key );
return -1;
}
ffc058b4: 80 01 00 1c lwz r0,28(r1)
ffc058b8: 83 a1 00 0c lwz r29,12(r1)
ffc058bc: 7c 08 03 a6 mtlr r0
ffc058c0: 83 c1 00 10 lwz r30,16(r1)
ffc058c4: 83 e1 00 14 lwz r31,20(r1)
ffc058c8: 38 21 00 18 addi r1,r1,24
ffc058cc: 4e 80 00 20 blr
/* 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 )
return 0;
free( new_key );
ffc058d0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc058d4: 4b ff fd 59 bl ffc0562c <free> <== NOT EXECUTED
return -1;
ffc058d8: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc058dc: 4b ff ff d8 b ffc058b4 <rtems_gxx_key_create+0x58> <== NOT EXECUTED
ffc058f0 <rtems_gxx_key_delete>:
int rtems_gxx_key_delete (__gthread_key_t key)
{
ffc058f0: 94 21 ff f0 stwu r1,-16(r1)
ffc058f4: 7c 08 02 a6 mflr r0
#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 );
ffc058f8: 7c 64 1b 78 mr r4,r3
key->val = 0;
return 0;
}
int rtems_gxx_key_delete (__gthread_key_t key)
{
ffc058fc: 93 e1 00 0c stw r31,12(r1)
ffc05900: 7c 7f 1b 78 mr r31,r3
#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 );
ffc05904: 38 60 00 00 li r3,0
key->val = 0;
return 0;
}
int rtems_gxx_key_delete (__gthread_key_t key)
{
ffc05908: 90 01 00 14 stw r0,20(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 );
ffc0590c: 48 00 4c 69 bl ffc0a574 <rtems_task_variable_delete>
if ( status == RTEMS_SUCCESSFUL ) {
ffc05910: 2f 83 00 00 cmpwi cr7,r3,0
ffc05914: 40 9e 00 14 bne- cr7,ffc05928 <rtems_gxx_key_delete+0x38><== NEVER TAKEN
/* Hmm - hopefully all tasks using this key have gone away... */
if ( key ) free( *(void **)key );
ffc05918: 2f 9f 00 00 cmpwi cr7,r31,0
ffc0591c: 41 9e 00 0c beq- cr7,ffc05928 <rtems_gxx_key_delete+0x38><== NEVER TAKEN
ffc05920: 80 7f 00 00 lwz r3,0(r31)
ffc05924: 4b ff fd 09 bl ffc0562c <free>
return 0;
}
key = NULL;
return 0;
}
ffc05928: 80 01 00 14 lwz r0,20(r1)
ffc0592c: 38 60 00 00 li r3,0
ffc05930: 83 e1 00 0c lwz r31,12(r1)
ffc05934: 38 21 00 10 addi r1,r1,16
ffc05938: 7c 08 03 a6 mtlr r0
ffc0593c: 4e 80 00 20 blr
ffc05a78 <rtems_gxx_mutex_lock>:
printk( "gxx_wrappers: mutex init complete =%X\n", *mutex );
#endif
}
int rtems_gxx_mutex_lock (__gthread_mutex_t *mutex)
{
ffc05a78: 94 21 ff f8 stwu r1,-8(r1)
ffc05a7c: 7c 08 02 a6 mflr r0
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: lock mutex=%X\n", *mutex );
#endif
status = rtems_semaphore_obtain(
ffc05a80: 38 80 00 00 li r4,0
printk( "gxx_wrappers: mutex init complete =%X\n", *mutex );
#endif
}
int rtems_gxx_mutex_lock (__gthread_mutex_t *mutex)
{
ffc05a84: 90 01 00 0c stw r0,12(r1)
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: lock mutex=%X\n", *mutex );
#endif
status = rtems_semaphore_obtain(
ffc05a88: 38 a0 00 00 li r5,0
ffc05a8c: 80 63 00 00 lwz r3,0(r3)
ffc05a90: 48 00 40 f5 bl ffc09b84 <rtems_semaphore_obtain>
*(rtems_id *)mutex,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
if ( status == RTEMS_SUCCESSFUL )
ffc05a94: 2f 83 00 00 cmpwi cr7,r3,0
return 0;
return -1;
ffc05a98: 38 60 ff ff li r3,-1
status = rtems_semaphore_obtain(
*(rtems_id *)mutex,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
if ( status == RTEMS_SUCCESSFUL )
ffc05a9c: 40 9e 00 08 bne- cr7,ffc05aa4 <rtems_gxx_mutex_lock+0x2c><== NEVER TAKEN
return 0;
ffc05aa0: 38 60 00 00 li r3,0
return -1;
}
ffc05aa4: 80 01 00 0c lwz r0,12(r1)
ffc05aa8: 38 21 00 08 addi r1,r1,8
ffc05aac: 7c 08 03 a6 mtlr r0
ffc05ab0: 4e 80 00 20 blr
ffc05ae8 <rtems_gxx_mutex_trylock>:
int rtems_gxx_mutex_trylock (__gthread_mutex_t *mutex)
{
ffc05ae8: 94 21 ff f8 stwu r1,-8(r1)
ffc05aec: 7c 08 02 a6 mflr r0
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: trylock mutex=%X\n", *mutex );
#endif
status = rtems_semaphore_obtain (*(rtems_id *)mutex, RTEMS_NO_WAIT, 0);
ffc05af0: 38 80 00 01 li r4,1
return 0;
return -1;
}
int rtems_gxx_mutex_trylock (__gthread_mutex_t *mutex)
{
ffc05af4: 90 01 00 0c stw r0,12(r1)
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: trylock mutex=%X\n", *mutex );
#endif
status = rtems_semaphore_obtain (*(rtems_id *)mutex, RTEMS_NO_WAIT, 0);
ffc05af8: 38 a0 00 00 li r5,0
ffc05afc: 80 63 00 00 lwz r3,0(r3)
ffc05b00: 48 00 40 85 bl ffc09b84 <rtems_semaphore_obtain>
if ( status == RTEMS_SUCCESSFUL )
ffc05b04: 2f 83 00 00 cmpwi cr7,r3,0
return 0;
return -1;
ffc05b08: 38 60 ff ff li r3,-1
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: trylock mutex=%X\n", *mutex );
#endif
status = rtems_semaphore_obtain (*(rtems_id *)mutex, RTEMS_NO_WAIT, 0);
if ( status == RTEMS_SUCCESSFUL )
ffc05b0c: 40 9e 00 08 bne- cr7,ffc05b14 <rtems_gxx_mutex_trylock+0x2c><== NEVER TAKEN
return 0;
ffc05b10: 38 60 00 00 li r3,0
return -1;
}
ffc05b14: 80 01 00 0c lwz r0,12(r1)
ffc05b18: 38 21 00 08 addi r1,r1,8
ffc05b1c: 7c 08 03 a6 mtlr r0
ffc05b20: 4e 80 00 20 blr
ffc05b24 <rtems_gxx_mutex_unlock>:
int rtems_gxx_mutex_unlock (__gthread_mutex_t *mutex)
{
ffc05b24: 94 21 ff f8 stwu r1,-8(r1)
ffc05b28: 7c 08 02 a6 mflr r0
ffc05b2c: 90 01 00 0c stw r0,12(r1)
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: unlock mutex=%X\n", *mutex );
#endif
status = rtems_semaphore_release( *(rtems_id *)mutex );
ffc05b30: 80 63 00 00 lwz r3,0(r3)
ffc05b34: 48 00 41 dd bl ffc09d10 <rtems_semaphore_release>
if ( status == RTEMS_SUCCESSFUL )
ffc05b38: 2f 83 00 00 cmpwi cr7,r3,0
return 0;
return -1;
ffc05b3c: 38 60 ff ff li r3,-1
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: unlock mutex=%X\n", *mutex );
#endif
status = rtems_semaphore_release( *(rtems_id *)mutex );
if ( status == RTEMS_SUCCESSFUL )
ffc05b40: 40 9e 00 08 bne- cr7,ffc05b48 <rtems_gxx_mutex_unlock+0x24><== NEVER TAKEN
return 0;
ffc05b44: 38 60 00 00 li r3,0
return -1;
}
ffc05b48: 80 01 00 0c lwz r0,12(r1)
ffc05b4c: 38 21 00 08 addi r1,r1,8
ffc05b50: 7c 08 03 a6 mtlr r0
ffc05b54: 4e 80 00 20 blr
ffc05794 <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))
{
ffc05794: 94 21 ff e0 stwu r1,-32(r1)
ffc05798: 7c 08 02 a6 mflr r0
ffc0579c: 90 01 00 24 stw r0,36(r1)
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );
#endif
if ( *(volatile __gthread_once_t *)once == 0 ) {
ffc057a0: 80 03 00 00 lwz r0,0(r3)
/* 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))
{
ffc057a4: 93 c1 00 18 stw r30,24(r1)
ffc057a8: 7c 9e 23 78 mr r30,r4
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );
#endif
if ( *(volatile __gthread_once_t *)once == 0 ) {
ffc057ac: 2f 80 00 00 cmpwi cr7,r0,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))
{
ffc057b0: 93 e1 00 1c stw r31,28(r1)
ffc057b4: 7c 7f 1b 78 mr r31,r3
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );
#endif
if ( *(volatile __gthread_once_t *)once == 0 ) {
ffc057b8: 41 9e 00 20 beq- cr7,ffc057d8 <rtems_gxx_once+0x44>
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
if ( o == 0 )
(*func)();
}
return 0;
}
ffc057bc: 80 01 00 24 lwz r0,36(r1)
ffc057c0: 38 60 00 00 li r3,0
ffc057c4: 83 c1 00 18 lwz r30,24(r1)
ffc057c8: 7c 08 03 a6 mtlr r0
ffc057cc: 83 e1 00 1c lwz r31,28(r1)
ffc057d0: 38 21 00 20 addi r1,r1,32
ffc057d4: 4e 80 00 20 blr
if ( *(volatile __gthread_once_t *)once == 0 ) {
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
ffc057d8: 38 60 01 00 li r3,256
ffc057dc: 38 80 01 00 li r4,256
ffc057e0: 38 a1 00 08 addi r5,r1,8
ffc057e4: 48 00 49 5d bl ffc0a140 <rtems_task_mode>
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
ffc057e8: 80 1f 00 00 lwz r0,0(r31)
ffc057ec: 2f 80 00 00 cmpwi cr7,r0,0
ffc057f0: 40 9e 00 40 bne- cr7,ffc05830 <rtems_gxx_once+0x9c> <== NEVER TAKEN
*(volatile __gthread_once_t *)once = 1;
ffc057f4: 38 00 00 01 li r0,1
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
ffc057f8: 80 61 00 08 lwz r3,8(r1)
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
*(volatile __gthread_once_t *)once = 1;
ffc057fc: 90 1f 00 00 stw r0,0(r31)
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
ffc05800: 38 a1 00 08 addi r5,r1,8
ffc05804: 38 80 01 00 li r4,256
ffc05808: 48 00 49 39 bl ffc0a140 <rtems_task_mode>
if ( o == 0 )
(*func)();
ffc0580c: 7f c9 03 a6 mtctr r30
ffc05810: 4e 80 04 21 bctrl
}
return 0;
}
ffc05814: 80 01 00 24 lwz r0,36(r1)
ffc05818: 38 60 00 00 li r3,0
ffc0581c: 83 c1 00 18 lwz r30,24(r1)
ffc05820: 7c 08 03 a6 mtlr r0
ffc05824: 83 e1 00 1c lwz r31,28(r1)
ffc05828: 38 21 00 20 addi r1,r1,32
ffc0582c: 4e 80 00 20 blr
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
*(volatile __gthread_once_t *)once = 1;
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
ffc05830: 80 61 00 08 lwz r3,8(r1) <== NOT EXECUTED
ffc05834: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
ffc05838: 38 80 01 00 li r4,256 <== NOT EXECUTED
ffc0583c: 48 00 49 05 bl ffc0a140 <rtems_task_mode> <== NOT EXECUTED
if ( o == 0 )
(*func)();
}
return 0;
}
ffc05840: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
ffc05844: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc05848: 83 c1 00 18 lwz r30,24(r1) <== NOT EXECUTED
ffc0584c: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc05850: 83 e1 00 1c lwz r31,28(r1) <== NOT EXECUTED
ffc05854: 38 21 00 20 addi r1,r1,32 <== NOT EXECUTED
ffc05858: 4e 80 00 20 blr <== NOT EXECUTED
ffc059d0 <rtems_gxx_setspecific>:
#endif
return p;
}
int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr)
{
ffc059d0: 94 21 ff f0 stwu r1,-16(r1)
ffc059d4: 7c 08 02 a6 mflr r0
ffc059d8: 90 01 00 14 stw r0,20(r1)
ffc059dc: 93 e1 00 0c stw r31,12(r1)
ffc059e0: 7c 7f 1b 78 mr r31,r3
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 );
ffc059e4: 80 a3 00 04 lwz r5,4(r3)
ffc059e8: 38 60 00 00 li r3,0
#endif
return p;
}
int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr)
{
ffc059ec: 93 c1 00 08 stw r30,8(r1)
ffc059f0: 7c 9e 23 78 mr r30,r4
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 );
ffc059f4: 7f e4 fb 78 mr r4,r31
ffc059f8: 48 00 4a 81 bl ffc0a478 <rtems_task_variable_add>
if ( status == RTEMS_SUCCESSFUL ) {
ffc059fc: 2f 83 00 00 cmpwi cr7,r3,0
/* now let's set the proper value */
key->val = (void *)ptr;
return 0;
}
return -1;
ffc05a00: 38 60 ff ff li 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 ) {
ffc05a04: 40 9e 00 0c bne- cr7,ffc05a10 <rtems_gxx_setspecific+0x40><== NEVER TAKEN
/* now let's set the proper value */
key->val = (void *)ptr;
ffc05a08: 93 df 00 00 stw r30,0(r31)
return 0;
ffc05a0c: 38 60 00 00 li r3,0
}
return -1;
}
ffc05a10: 80 01 00 14 lwz r0,20(r1)
ffc05a14: 83 c1 00 08 lwz r30,8(r1)
ffc05a18: 7c 08 03 a6 mtlr r0
ffc05a1c: 83 e1 00 0c lwz r31,12(r1)
ffc05a20: 38 21 00 10 addi r1,r1,16
ffc05a24: 4e 80 00 20 blr
ffc09ca4 <rtems_heap_allocate_aligned_with_boundary>:
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
ffc09ca4: 94 21 ff e8 stwu r1,-24(r1)
ffc09ca8: 7c 08 02 a6 mflr r0
if (
ffc09cac: 3d 20 00 00 lis r9,0
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
ffc09cb0: 90 01 00 1c stw r0,28(r1)
if (
ffc09cb4: 80 09 28 c4 lwz r0,10436(r9)
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
ffc09cb8: 93 a1 00 0c stw r29,12(r1)
ffc09cbc: 7c 7d 1b 78 mr r29,r3
if (
ffc09cc0: 2f 80 00 03 cmpwi cr7,r0,3
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
ffc09cc4: 93 c1 00 10 stw r30,16(r1)
ffc09cc8: 7c 9e 23 78 mr r30,r4
ffc09ccc: 93 e1 00 14 stw r31,20(r1)
ffc09cd0: 7c bf 2b 78 mr r31,r5
if (
ffc09cd4: 41 9e 00 3c beq- cr7,ffc09d10 <rtems_heap_allocate_aligned_with_boundary+0x6c><== ALWAYS TAKEN
&& !malloc_is_system_state_OK()
) {
return NULL;
}
malloc_deferred_frees_process();
ffc09cd8: 4b ff ea 41 bl ffc08718 <malloc_deferred_frees_process>
/* FIXME: Statistics, boundary checks */
return _Protected_heap_Allocate_aligned_with_boundary(
ffc09cdc: 3d 20 00 00 lis r9,0
ffc09ce0: 80 69 27 90 lwz r3,10128(r9)
ffc09ce4: 7f a4 eb 78 mr r4,r29
ffc09ce8: 7f c5 f3 78 mr r5,r30
ffc09cec: 7f e6 fb 78 mr r6,r31
ffc09cf0: 48 00 65 ad bl ffc1029c <_Protected_heap_Allocate_aligned_with_boundary>
RTEMS_Malloc_Heap,
size,
alignment,
boundary
);
}
ffc09cf4: 80 01 00 1c lwz r0,28(r1)
ffc09cf8: 83 a1 00 0c lwz r29,12(r1)
ffc09cfc: 7c 08 03 a6 mtlr r0
ffc09d00: 83 c1 00 10 lwz r30,16(r1)
ffc09d04: 83 e1 00 14 lwz r31,20(r1)
ffc09d08: 38 21 00 18 addi r1,r1,24
ffc09d0c: 4e 80 00 20 blr
uintptr_t boundary
)
{
if (
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
ffc09d10: 4b ff e9 c1 bl ffc086d0 <malloc_is_system_state_OK>
ffc09d14: 2f 83 00 00 cmpwi cr7,r3,0
) {
return NULL;
ffc09d18: 38 60 00 00 li r3,0
uintptr_t boundary
)
{
if (
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
ffc09d1c: 40 9e ff bc bne+ cr7,ffc09cd8 <rtems_heap_allocate_aligned_with_boundary+0x34>
ffc09d20: 4b ff ff d4 b ffc09cf4 <rtems_heap_allocate_aligned_with_boundary+0x50>
ffc04930 <rtems_io_lookup_name>:
rtems_status_code rtems_io_lookup_name(
const char *name,
rtems_driver_name_t *device_info
)
{
ffc04930: 94 21 ff c8 stwu r1,-56(r1)
ffc04934: 7c 08 02 a6 mflr r0
ffc04938: 93 81 00 28 stw r28,40(r1)
ffc0493c: 90 01 00 3c stw r0,60(r1)
ffc04940: 93 a1 00 2c stw r29,44(r1)
ffc04944: 93 c1 00 30 stw r30,48(r1)
ffc04948: 7c 9e 23 78 mr r30,r4
ffc0494c: 93 e1 00 34 stw r31,52(r1)
ffc04950: 7c 7f 1b 78 mr r31,r3
IMFS_jnode_t *the_jnode;
rtems_filesystem_location_info_t loc;
int result;
rtems_filesystem_node_types_t node_type;
result = rtems_filesystem_evaluate_path(
ffc04954: 48 01 0d 65 bl ffc156b8 <strlen>
ffc04958: 38 a0 00 00 li r5,0
ffc0495c: 7c 64 1b 78 mr r4,r3
ffc04960: 38 c1 00 08 addi r6,r1,8
ffc04964: 38 e0 00 01 li r7,1
ffc04968: 7f e3 fb 78 mr r3,r31
ffc0496c: 48 00 06 a9 bl ffc05014 <rtems_filesystem_evaluate_path>
name, strlen( name ), 0x00, &loc, true );
the_jnode = loc.node_access;
node_type = (*loc.ops->node_type_h)( &loc );
ffc04970: 81 21 00 14 lwz r9,20(r1)
IMFS_jnode_t *the_jnode;
rtems_filesystem_location_info_t loc;
int result;
rtems_filesystem_node_types_t node_type;
result = rtems_filesystem_evaluate_path(
ffc04974: 7c 7d 1b 78 mr r29,r3
name, strlen( name ), 0x00, &loc, true );
the_jnode = loc.node_access;
ffc04978: 83 81 00 08 lwz r28,8(r1)
node_type = (*loc.ops->node_type_h)( &loc );
ffc0497c: 80 09 00 10 lwz r0,16(r9)
ffc04980: 38 61 00 08 addi r3,r1,8
ffc04984: 7c 09 03 a6 mtctr r0
ffc04988: 4e 80 04 21 bctrl
if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {
ffc0498c: 2f 9d 00 00 cmpwi cr7,r29,0
ffc04990: 40 9e 00 0c bne- cr7,ffc0499c <rtems_io_lookup_name+0x6c><== NEVER TAKEN
ffc04994: 2f 83 00 02 cmpwi cr7,r3,2
ffc04998: 41 9e 00 30 beq- cr7,ffc049c8 <rtems_io_lookup_name+0x98>
rtems_filesystem_freenode( &loc );
ffc0499c: 38 61 00 08 addi r3,r1,8
ffc049a0: 48 00 07 d1 bl ffc05170 <rtems_filesystem_freenode>
return RTEMS_UNSATISFIED;
ffc049a4: 38 60 00 0d li r3,13
device_info->minor = the_jnode->info.device.minor;
rtems_filesystem_freenode( &loc );
return RTEMS_SUCCESSFUL;
}
ffc049a8: 80 01 00 3c lwz r0,60(r1)
ffc049ac: 83 81 00 28 lwz r28,40(r1)
ffc049b0: 7c 08 03 a6 mtlr r0
ffc049b4: 83 a1 00 2c lwz r29,44(r1)
ffc049b8: 83 c1 00 30 lwz r30,48(r1)
ffc049bc: 83 e1 00 34 lwz r31,52(r1)
ffc049c0: 38 21 00 38 addi r1,r1,56
ffc049c4: 4e 80 00 20 blr
if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {
rtems_filesystem_freenode( &loc );
return RTEMS_UNSATISFIED;
}
device_info->device_name = (char *) name;
ffc049c8: 93 fe 00 00 stw r31,0(r30)
device_info->device_name_length = strlen( name );
ffc049cc: 7f e3 fb 78 mr r3,r31
ffc049d0: 48 01 0c e9 bl ffc156b8 <strlen>
ffc049d4: 90 7e 00 04 stw r3,4(r30)
device_info->major = the_jnode->info.device.major;
device_info->minor = the_jnode->info.device.minor;
rtems_filesystem_freenode( &loc );
ffc049d8: 38 61 00 08 addi r3,r1,8
return RTEMS_UNSATISFIED;
}
device_info->device_name = (char *) name;
device_info->device_name_length = strlen( name );
device_info->major = the_jnode->info.device.major;
ffc049dc: 80 1c 00 50 lwz r0,80(r28)
ffc049e0: 90 1e 00 08 stw r0,8(r30)
device_info->minor = the_jnode->info.device.minor;
ffc049e4: 80 1c 00 54 lwz r0,84(r28)
ffc049e8: 90 1e 00 0c stw r0,12(r30)
rtems_filesystem_freenode( &loc );
ffc049ec: 48 00 07 85 bl ffc05170 <rtems_filesystem_freenode>
return RTEMS_SUCCESSFUL;
ffc049f0: 38 60 00 00 li r3,0
ffc049f4: 4b ff ff b4 b ffc049a8 <rtems_io_lookup_name+0x78>
ffc0ac40 <rtems_io_register_driver>:
rtems_status_code rtems_io_register_driver(
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
ffc0ac40: 94 21 ff f0 stwu r1,-16(r1)
ffc0ac44: 7c 08 02 a6 mflr r0
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
ffc0ac48: 3d 20 00 00 lis r9,0
rtems_status_code rtems_io_register_driver(
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
ffc0ac4c: 90 01 00 14 stw r0,20(r1)
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
ffc0ac50: 80 09 31 ec lwz r0,12780(r9)
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
ffc0ac54: 3d 20 00 00 lis r9,0
rtems_status_code rtems_io_register_driver(
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
ffc0ac58: 93 e1 00 0c stw r31,12(r1)
ffc0ac5c: 7c 7f 1b 78 mr r31,r3
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
ffc0ac60: 2f 80 00 00 cmpwi cr7,r0,0
return RTEMS_CALLED_FROM_ISR;
ffc0ac64: 38 60 00 12 li r3,18
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
ffc0ac68: 80 09 28 50 lwz r0,10320(r9)
if ( rtems_interrupt_is_in_progress() )
ffc0ac6c: 41 9e 00 18 beq- cr7,ffc0ac84 <rtems_io_register_driver+0x44>
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
}
ffc0ac70: 80 01 00 14 lwz r0,20(r1)
ffc0ac74: 83 e1 00 0c lwz r31,12(r1)
ffc0ac78: 38 21 00 10 addi r1,r1,16
ffc0ac7c: 7c 08 03 a6 mtlr r0
ffc0ac80: 4e 80 00 20 blr
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
ffc0ac84: 2f 85 00 00 cmpwi cr7,r5,0
return RTEMS_INVALID_ADDRESS;
ffc0ac88: 38 60 00 09 li r3,9
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
ffc0ac8c: 41 be ff e4 beq- cr7,ffc0ac70 <rtems_io_register_driver+0x30>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
if ( driver_table == NULL )
ffc0ac90: 2f 84 00 00 cmpwi cr7,r4,0
if ( registered_major == NULL )
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
ffc0ac94: 90 05 00 00 stw r0,0(r5)
if ( driver_table == NULL )
ffc0ac98: 41 be ff d8 beq- cr7,ffc0ac70 <rtems_io_register_driver+0x30>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
ffc0ac9c: 81 64 00 00 lwz r11,0(r4)
ffc0aca0: 2f 8b 00 00 cmpwi cr7,r11,0
ffc0aca4: 41 9e 00 f4 beq- cr7,ffc0ad98 <rtems_io_register_driver+0x158>
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
ffc0aca8: 7f 80 f8 40 cmplw cr7,r0,r31
return RTEMS_INVALID_NUMBER;
ffc0acac: 38 60 00 0a li r3,10
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
ffc0acb0: 40 9d ff c0 ble+ cr7,ffc0ac70 <rtems_io_register_driver+0x30>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc0acb4: 3d 60 00 00 lis r11,0
ffc0acb8: 81 4b 28 04 lwz r10,10244(r11)
ffc0acbc: 38 0a 00 01 addi r0,r10,1
ffc0acc0: 90 0b 28 04 stw r0,10244(r11)
return _Thread_Dispatch_disable_level;
ffc0acc4: 80 0b 28 04 lwz r0,10244(r11)
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
ffc0acc8: 2f 9f 00 00 cmpwi cr7,r31,0
ffc0accc: 40 9e 00 a4 bne- cr7,ffc0ad70 <rtems_io_register_driver+0x130>
static rtems_status_code rtems_io_obtain_major_number(
rtems_device_major_number *major
)
{
rtems_device_major_number n = _IO_Number_of_drivers;
ffc0acd0: 81 49 28 50 lwz r10,10320(r9)
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
ffc0acd4: 2f 8a 00 00 cmpwi cr7,r10,0
ffc0acd8: 41 9e 00 d0 beq- cr7,ffc0ada8 <rtems_io_register_driver+0x168><== NEVER TAKEN
ffc0acdc: 3d 60 00 00 lis r11,0
ffc0ace0: 7d 49 03 a6 mtctr r10
ffc0ace4: 81 2b 28 54 lwz r9,10324(r11)
ffc0ace8: 48 00 00 10 b ffc0acf8 <rtems_io_register_driver+0xb8>
ffc0acec: 3b ff 00 01 addi r31,r31,1
ffc0acf0: 39 29 00 18 addi r9,r9,24
ffc0acf4: 42 40 00 b4 bdz- ffc0ada8 <rtems_io_register_driver+0x168>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
ffc0acf8: 80 09 00 00 lwz r0,0(r9)
ffc0acfc: 2f 80 00 00 cmpwi cr7,r0,0
ffc0ad00: 40 9e ff ec bne+ cr7,ffc0acec <rtems_io_register_driver+0xac>
ffc0ad04: 80 09 00 04 lwz r0,4(r9)
ffc0ad08: 2f 80 00 00 cmpwi cr7,r0,0
ffc0ad0c: 40 9e ff e0 bne+ cr7,ffc0acec <rtems_io_register_driver+0xac>
}
/* Assigns invalid value in case of failure */
*major = m;
if ( m != n )
ffc0ad10: 7f 8a f8 00 cmpw cr7,r10,r31
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
ffc0ad14: 93 e5 00 00 stw r31,0(r5)
ffc0ad18: 1c 1f 00 18 mulli r0,r31,24
if ( m != n )
ffc0ad1c: 41 9e 00 90 beq- cr7,ffc0adac <rtems_io_register_driver+0x16c><== NEVER TAKEN
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
ffc0ad20: 81 6b 28 54 lwz r11,10324(r11)
ffc0ad24: 80 c4 00 00 lwz r6,0(r4)
ffc0ad28: 80 e4 00 04 lwz r7,4(r4)
ffc0ad2c: 7d 2b 02 14 add r9,r11,r0
ffc0ad30: 81 04 00 08 lwz r8,8(r4)
ffc0ad34: 81 44 00 0c lwz r10,12(r4)
ffc0ad38: 7c cb 01 2e stwx r6,r11,r0
ffc0ad3c: 90 e9 00 04 stw r7,4(r9)
ffc0ad40: 91 09 00 08 stw r8,8(r9)
ffc0ad44: 91 49 00 0c stw r10,12(r9)
ffc0ad48: 81 64 00 10 lwz r11,16(r4)
ffc0ad4c: 80 04 00 14 lwz r0,20(r4)
ffc0ad50: 91 69 00 10 stw r11,16(r9)
ffc0ad54: 90 09 00 14 stw r0,20(r9)
_Thread_Enable_dispatch();
ffc0ad58: 48 00 27 59 bl ffc0d4b0 <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
ffc0ad5c: 7f e3 fb 78 mr r3,r31
ffc0ad60: 38 80 00 00 li r4,0
ffc0ad64: 38 a0 00 00 li r5,0
ffc0ad68: 48 00 a7 6d bl ffc154d4 <rtems_io_initialize>
ffc0ad6c: 4b ff ff 04 b ffc0ac70 <rtems_io_register_driver+0x30>
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
ffc0ad70: 3d 60 00 00 lis r11,0
ffc0ad74: 1c 1f 00 18 mulli r0,r31,24
ffc0ad78: 81 2b 28 54 lwz r9,10324(r11)
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
ffc0ad7c: 7d 49 00 2e lwzx r10,r9,r0
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
ffc0ad80: 7d 29 02 14 add r9,r9,r0
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
ffc0ad84: 2f 8a 00 00 cmpwi cr7,r10,0
ffc0ad88: 41 9e 00 30 beq- cr7,ffc0adb8 <rtems_io_register_driver+0x178>
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
ffc0ad8c: 48 00 27 25 bl ffc0d4b0 <_Thread_Enable_dispatch>
return RTEMS_RESOURCE_IN_USE;
ffc0ad90: 38 60 00 0c li r3,12
ffc0ad94: 4b ff fe dc b ffc0ac70 <rtems_io_register_driver+0x30>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
ffc0ad98: 81 64 00 04 lwz r11,4(r4)
ffc0ad9c: 2f 8b 00 00 cmpwi cr7,r11,0
ffc0ada0: 40 9e ff 08 bne+ cr7,ffc0aca8 <rtems_io_register_driver+0x68>
ffc0ada4: 4b ff fe cc b ffc0ac70 <rtems_io_register_driver+0x30>
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
ffc0ada8: 93 e5 00 00 stw r31,0(r5)
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
ffc0adac: 48 00 27 05 bl ffc0d4b0 <_Thread_Enable_dispatch>
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
ffc0adb0: 38 60 00 05 li r3,5
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
return sc;
ffc0adb4: 4b ff fe bc b ffc0ac70 <rtems_io_register_driver+0x30>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
ffc0adb8: 81 29 00 04 lwz r9,4(r9)
ffc0adbc: 2f 89 00 00 cmpwi cr7,r9,0
ffc0adc0: 40 9e ff cc bne+ cr7,ffc0ad8c <rtems_io_register_driver+0x14c>
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
*registered_major = major;
ffc0adc4: 93 e5 00 00 stw r31,0(r5)
ffc0adc8: 4b ff ff 58 b ffc0ad20 <rtems_io_register_driver+0xe0>
ffc0c91c <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)
{
ffc0c91c: 94 21 ff e0 stwu r1,-32(r1)
ffc0c920: 7c 08 02 a6 mflr r0
ffc0c924: 90 01 00 24 stw r0,36(r1)
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
ffc0c928: 7c 60 1b 79 mr. r0,r3
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
{
ffc0c92c: 93 81 00 10 stw r28,16(r1)
ffc0c930: 93 a1 00 14 stw r29,20(r1)
ffc0c934: 93 c1 00 18 stw r30,24(r1)
ffc0c938: 93 e1 00 1c stw r31,28(r1)
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
ffc0c93c: 90 01 00 08 stw r0,8(r1)
ffc0c940: 41 82 00 6c beq- ffc0c9ac <rtems_iterate_over_all_threads+0x90><== NEVER TAKEN
ffc0c944: 3f a0 00 00 lis r29,0
ffc0c948: 3b bd 30 80 addi r29,r29,12416
#endif
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
ffc0c94c: 3b 9d 00 0c addi r28,r29,12
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
ffc0c950: 85 3d 00 04 lwzu r9,4(r29)
ffc0c954: 83 c9 00 04 lwz r30,4(r9)
if ( !information )
ffc0c958: 2f 9e 00 00 cmpwi cr7,r30,0
ffc0c95c: 41 9e 00 48 beq- cr7,ffc0c9a4 <rtems_iterate_over_all_threads+0x88>
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
ffc0c960: a0 1e 00 10 lhz r0,16(r30)
ffc0c964: 70 09 ff ff andi. r9,r0,65535
ffc0c968: 41 82 00 3c beq- ffc0c9a4 <rtems_iterate_over_all_threads+0x88>
ffc0c96c: 3b e0 00 01 li r31,1
the_thread = (Thread_Control *)information->local_table[ i ];
ffc0c970: 81 7e 00 1c lwz r11,28(r30)
ffc0c974: 57 e9 10 3a rlwinm r9,r31,2,0,29
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
ffc0c978: 3b ff 00 01 addi r31,r31,1
the_thread = (Thread_Control *)information->local_table[ i ];
ffc0c97c: 7c 6b 48 2e lwzx r3,r11,r9
if ( !the_thread )
ffc0c980: 2f 83 00 00 cmpwi cr7,r3,0
ffc0c984: 41 9e 00 14 beq- cr7,ffc0c998 <rtems_iterate_over_all_threads+0x7c>
continue;
(*routine)(the_thread);
ffc0c988: 80 01 00 08 lwz r0,8(r1)
ffc0c98c: 7c 09 03 a6 mtctr r0
ffc0c990: 4e 80 04 21 bctrl
ffc0c994: a0 1e 00 10 lhz r0,16(r30)
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
ffc0c998: 54 09 04 3e clrlwi r9,r0,16
ffc0c99c: 7f 89 f8 40 cmplw cr7,r9,r31
ffc0c9a0: 40 9c ff d0 bge+ cr7,ffc0c970 <rtems_iterate_over_all_threads+0x54>
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
ffc0c9a4: 7f 9d e0 00 cmpw cr7,r29,r28
ffc0c9a8: 40 9e ff a8 bne+ cr7,ffc0c950 <rtems_iterate_over_all_threads+0x34>
(*routine)(the_thread);
}
}
}
ffc0c9ac: 80 01 00 24 lwz r0,36(r1)
ffc0c9b0: 83 81 00 10 lwz r28,16(r1)
ffc0c9b4: 7c 08 03 a6 mtlr r0
ffc0c9b8: 83 a1 00 14 lwz r29,20(r1)
ffc0c9bc: 83 c1 00 18 lwz r30,24(r1)
ffc0c9c0: 83 e1 00 1c lwz r31,28(r1)
ffc0c9c4: 38 21 00 20 addi r1,r1,32
ffc0c9c8: 4e 80 00 20 blr
ffc0f6f0 <rtems_libio_free>:
*/
void rtems_libio_free(
rtems_libio_t *iop
)
{
ffc0f6f0: 94 21 ff f0 stwu r1,-16(r1)
ffc0f6f4: 7c 08 02 a6 mflr r0
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 );
ffc0f6f8: 38 80 00 00 li r4,0
ffc0f6fc: 93 c1 00 08 stw r30,8(r1)
ffc0f700: 3f c0 00 00 lis r30,0
ffc0f704: 38 a0 00 00 li r5,0
ffc0f708: 93 e1 00 0c stw r31,12(r1)
ffc0f70c: 7c 7f 1b 78 mr r31,r3
ffc0f710: 80 7e 27 f8 lwz r3,10232(r30)
ffc0f714: 90 01 00 14 stw r0,20(r1)
ffc0f718: 4b ff 9c c1 bl ffc093d8 <rtems_semaphore_obtain>
rtems_libio_lock();
if (iop->sem)
ffc0f71c: 80 7f 00 30 lwz r3,48(r31)
ffc0f720: 2f 83 00 00 cmpwi cr7,r3,0
ffc0f724: 41 be 00 08 beq+ cr7,ffc0f72c <rtems_libio_free+0x3c> <== NEVER TAKEN
rtems_semaphore_delete(iop->sem);
ffc0f728: 4b ff 9b d5 bl ffc092fc <rtems_semaphore_delete>
iop->flags &= ~LIBIO_FLAGS_OPEN;
ffc0f72c: 81 7f 00 18 lwz r11,24(r31)
iop->data1 = rtems_libio_iop_freelist;
ffc0f730: 3d 20 00 00 lis r9,0
ffc0f734: 80 09 27 f4 lwz r0,10228(r9)
rtems_libio_lock();
if (iop->sem)
rtems_semaphore_delete(iop->sem);
iop->flags &= ~LIBIO_FLAGS_OPEN;
ffc0f738: 55 6b 06 2c rlwinm r11,r11,0,24,22
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
ffc0f73c: 80 7e 27 f8 lwz r3,10232(r30)
iop->data1 = rtems_libio_iop_freelist;
ffc0f740: 90 1f 00 38 stw r0,56(r31)
rtems_libio_lock();
if (iop->sem)
rtems_semaphore_delete(iop->sem);
iop->flags &= ~LIBIO_FLAGS_OPEN;
ffc0f744: 91 7f 00 18 stw r11,24(r31)
iop->data1 = rtems_libio_iop_freelist;
rtems_libio_iop_freelist = iop;
ffc0f748: 93 e9 27 f4 stw r31,10228(r9)
ffc0f74c: 4b ff 9e 19 bl ffc09564 <rtems_semaphore_release>
rtems_libio_unlock();
}
ffc0f750: 80 01 00 14 lwz r0,20(r1)
ffc0f754: 83 c1 00 08 lwz r30,8(r1)
ffc0f758: 7c 08 03 a6 mtlr r0
ffc0f75c: 83 e1 00 0c lwz r31,12(r1)
ffc0f760: 38 21 00 10 addi r1,r1,16
ffc0f764: 4e 80 00 20 blr
ffc05304 <rtems_libio_init>:
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
ffc05304: 94 21 ff f0 stwu r1,-16(r1)
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
ffc05308: 3d 20 00 00 lis r9,0
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
ffc0530c: 7c 08 02 a6 mflr r0
ffc05310: 93 e1 00 0c stw r31,12(r1)
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
ffc05314: 83 e9 27 3c lwz r31,10044(r9)
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
ffc05318: 90 01 00 14 stw r0,20(r1)
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
ffc0531c: 2f 9f 00 00 cmpwi cr7,r31,0
ffc05320: 41 9e 00 64 beq- cr7,ffc05384 <rtems_libio_init+0x80> <== NEVER TAKEN
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
ffc05324: 7f e3 fb 78 mr r3,r31
ffc05328: 38 80 00 40 li r4,64
ffc0532c: 4b ff f8 6d bl ffc04b98 <calloc>
ffc05330: 3d 20 00 00 lis r9,0
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
ffc05334: 2f 83 00 00 cmpwi cr7,r3,0
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
ffc05338: 90 69 27 f0 stw r3,10224(r9)
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
ffc0533c: 41 9e 00 a0 beq- cr7,ffc053dc <rtems_libio_init+0xd8>
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++)
ffc05340: 2b 9f 00 01 cmplwi cr7,r31,1
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
ffc05344: 3d 20 00 00 lis r9,0
ffc05348: 90 69 27 f4 stw r3,10228(r9)
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
ffc0534c: 40 9d 00 30 ble- cr7,ffc0537c <rtems_libio_init+0x78> <== NEVER TAKEN
ffc05350: 3b ff ff ff addi r31,r31,-1
ffc05354: 7f e9 03 a6 mtctr r31
ffc05358: 7c 69 1b 78 mr r9,r3
ffc0535c: 39 60 00 01 li r11,1
iop->data1 = iop + 1;
ffc05360: 39 29 00 40 addi r9,r9,64
ffc05364: 91 29 ff f8 stw r9,-8(r9)
ffc05368: 39 6b 00 01 addi r11,r11,1
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
ffc0536c: 42 00 ff f4 bdnz+ ffc05360 <rtems_libio_init+0x5c>
* rtems_libio_init
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
ffc05370: 39 6b ff ff addi r11,r11,-1
ffc05374: 55 6b 30 32 rlwinm r11,r11,6,0,25
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++)
ffc05378: 7c 63 5a 14 add r3,r3,r11
iop->data1 = iop + 1;
iop->data1 = NULL;
ffc0537c: 38 00 00 00 li r0,0
ffc05380: 90 03 00 38 stw r0,56(r3)
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
ffc05384: 3c 60 4c 42 lis r3,19522
ffc05388: 3c e0 00 00 lis r7,0
ffc0538c: 60 63 49 4f ori r3,r3,18767
ffc05390: 38 80 00 01 li r4,1
ffc05394: 38 a0 00 54 li r5,84
ffc05398: 38 c0 00 00 li r6,0
ffc0539c: 38 e7 27 f8 addi r7,r7,10232
ffc053a0: 48 00 3d 61 bl ffc09100 <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
ffc053a4: 2f 83 00 00 cmpwi cr7,r3,0
ffc053a8: 40 9e 00 30 bne- cr7,ffc053d8 <rtems_libio_init+0xd4> <== NEVER TAKEN
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
ffc053ac: 3d 20 00 00 lis r9,0
ffc053b0: 80 09 27 40 lwz r0,10048(r9)
ffc053b4: 2f 80 00 00 cmpwi cr7,r0,0
ffc053b8: 41 9e 00 0c beq- cr7,ffc053c4 <rtems_libio_init+0xc0> <== NEVER TAKEN
(* rtems_fs_init_helper)();
ffc053bc: 7c 09 03 a6 mtctr r0
ffc053c0: 4e 80 04 21 bctrl
}
ffc053c4: 80 01 00 14 lwz r0,20(r1)
ffc053c8: 83 e1 00 0c lwz r31,12(r1)
ffc053cc: 38 21 00 10 addi r1,r1,16
ffc053d0: 7c 08 03 a6 mtlr r0
ffc053d4: 4e 80 00 20 blr
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
rtems_fatal_error_occurred( rc );
ffc053d8: 48 00 49 69 bl ffc09d40 <rtems_fatal_error_occurred> <== NOT EXECUTED
if (rtems_libio_number_iops > 0)
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
ffc053dc: 38 60 00 1a li r3,26
ffc053e0: 48 00 49 61 bl ffc09d40 <rtems_fatal_error_occurred>
ffc0f830 <rtems_libio_is_file_open>:
*/
int rtems_libio_is_file_open(
void *node_access
)
{
ffc0f830: 94 21 ff e8 stwu r1,-24(r1)
ffc0f834: 7c 08 02 a6 mflr r0
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 );
ffc0f838: 38 80 00 00 li r4,0
ffc0f83c: 93 c1 00 10 stw r30,16(r1)
ffc0f840: 3f c0 00 00 lis r30,0
ffc0f844: 38 a0 00 00 li r5,0
ffc0f848: 93 e1 00 14 stw r31,20(r1)
ffc0f84c: 7c 7f 1b 78 mr r31,r3
ffc0f850: 80 7e 27 f8 lwz r3,10232(r30)
ffc0f854: 90 01 00 1c stw r0,28(r1)
ffc0f858: 93 a1 00 0c stw r29,12(r1)
ffc0f85c: 4b ff 9b 7d bl ffc093d8 <rtems_semaphore_obtain>
/*
* Look for any active file descriptor entry.
*/
for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
ffc0f860: 3d 20 00 00 lis r9,0
ffc0f864: 80 09 27 3c lwz r0,10044(r9)
ffc0f868: 3d 20 00 00 lis r9,0
ffc0f86c: 81 29 27 f0 lwz r9,10224(r9)
int rtems_libio_is_file_open(
void *node_access
)
{
rtems_libio_t *iop;
int result=0;
ffc0f870: 3b a0 00 00 li r29,0
/*
* Look for any active file descriptor entry.
*/
for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
ffc0f874: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f878: 41 9e 00 2c beq- cr7,ffc0f8a4 <rtems_libio_is_file_open+0x74><== NEVER TAKEN
ffc0f87c: 7c 09 03 a6 mtctr r0
if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) {
ffc0f880: 80 09 00 18 lwz r0,24(r9)
ffc0f884: 70 0b 01 00 andi. r11,r0,256
ffc0f888: 41 82 00 10 beq- ffc0f898 <rtems_libio_is_file_open+0x68>
/*
* Check if this node is under the file system that we
* are trying to dismount.
*/
if ( iop->pathinfo.node_access == node_access ) {
ffc0f88c: 80 09 00 1c lwz r0,28(r9)
ffc0f890: 7f 80 f8 00 cmpw cr7,r0,r31
ffc0f894: 41 9e 00 38 beq- cr7,ffc0f8cc <rtems_libio_is_file_open+0x9c>
/*
* Look for any active file descriptor entry.
*/
for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
ffc0f898: 39 29 00 40 addi r9,r9,64
ffc0f89c: 42 00 ff e4 bdnz+ ffc0f880 <rtems_libio_is_file_open+0x50>
int rtems_libio_is_file_open(
void *node_access
)
{
rtems_libio_t *iop;
int result=0;
ffc0f8a0: 3b a0 00 00 li r29,0
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
ffc0f8a4: 80 7e 27 f8 lwz r3,10232(r30)
ffc0f8a8: 4b ff 9c bd bl ffc09564 <rtems_semaphore_release>
}
rtems_libio_unlock();
return result;
}
ffc0f8ac: 80 01 00 1c lwz r0,28(r1)
ffc0f8b0: 7f a3 eb 78 mr r3,r29
ffc0f8b4: 83 c1 00 10 lwz r30,16(r1)
ffc0f8b8: 7c 08 03 a6 mtlr r0
ffc0f8bc: 83 a1 00 0c lwz r29,12(r1)
ffc0f8c0: 83 e1 00 14 lwz r31,20(r1)
ffc0f8c4: 38 21 00 18 addi r1,r1,24
ffc0f8c8: 4e 80 00 20 blr
ffc0f8cc: 80 7e 27 f8 lwz r3,10232(r30)
* Check if this node is under the file system that we
* are trying to dismount.
*/
if ( iop->pathinfo.node_access == node_access ) {
result = 1;
ffc0f8d0: 3b a0 00 01 li r29,1
ffc0f8d4: 4b ff 9c 91 bl ffc09564 <rtems_semaphore_release>
}
rtems_libio_unlock();
return result;
}
ffc0f8d8: 80 01 00 1c lwz r0,28(r1)
ffc0f8dc: 7f a3 eb 78 mr r3,r29
ffc0f8e0: 83 c1 00 10 lwz r30,16(r1)
ffc0f8e4: 7c 08 03 a6 mtlr r0
ffc0f8e8: 83 a1 00 0c lwz r29,12(r1)
ffc0f8ec: 83 e1 00 14 lwz r31,20(r1)
ffc0f8f0: 38 21 00 18 addi r1,r1,24
ffc0f8f4: 4e 80 00 20 blr
ffc0f768 <rtems_libio_is_open_files_in_fs>:
*/
int rtems_libio_is_open_files_in_fs(
rtems_filesystem_mount_table_entry_t * fs_mt_entry
)
{
ffc0f768: 94 21 ff e8 stwu r1,-24(r1)
ffc0f76c: 7c 08 02 a6 mflr r0
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 );
ffc0f770: 38 80 00 00 li r4,0
ffc0f774: 93 c1 00 10 stw r30,16(r1)
ffc0f778: 3f c0 00 00 lis r30,0
ffc0f77c: 38 a0 00 00 li r5,0
ffc0f780: 93 e1 00 14 stw r31,20(r1)
ffc0f784: 7c 7f 1b 78 mr r31,r3
ffc0f788: 80 7e 27 f8 lwz r3,10232(r30)
ffc0f78c: 90 01 00 1c stw r0,28(r1)
ffc0f790: 93 a1 00 0c stw r29,12(r1)
ffc0f794: 4b ff 9c 45 bl ffc093d8 <rtems_semaphore_obtain>
/*
* Look for any active file descriptor entry.
*/
for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
ffc0f798: 3d 20 00 00 lis r9,0
ffc0f79c: 80 09 27 3c lwz r0,10044(r9)
ffc0f7a0: 3d 20 00 00 lis r9,0
ffc0f7a4: 81 29 27 f0 lwz r9,10224(r9)
int rtems_libio_is_open_files_in_fs(
rtems_filesystem_mount_table_entry_t * fs_mt_entry
)
{
rtems_libio_t *iop;
int result = 0;
ffc0f7a8: 3b a0 00 00 li r29,0
/*
* Look for any active file descriptor entry.
*/
for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
ffc0f7ac: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f7b0: 41 9e 00 2c beq- cr7,ffc0f7dc <rtems_libio_is_open_files_in_fs+0x74><== NEVER TAKEN
ffc0f7b4: 7c 09 03 a6 mtctr r0
if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) {
ffc0f7b8: 80 09 00 18 lwz r0,24(r9)
ffc0f7bc: 70 0b 01 00 andi. r11,r0,256
ffc0f7c0: 41 82 00 10 beq- ffc0f7d0 <rtems_libio_is_open_files_in_fs+0x68>
/*
* Check if this node is under the file system that we
* are trying to dismount.
*/
if ( iop->pathinfo.mt_entry == fs_mt_entry ) {
ffc0f7c4: 80 09 00 2c lwz r0,44(r9)
ffc0f7c8: 7f 80 f8 00 cmpw cr7,r0,r31
ffc0f7cc: 41 9e 00 38 beq- cr7,ffc0f804 <rtems_libio_is_open_files_in_fs+0x9c>
/*
* Look for any active file descriptor entry.
*/
for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
ffc0f7d0: 39 29 00 40 addi r9,r9,64
ffc0f7d4: 42 00 ff e4 bdnz+ ffc0f7b8 <rtems_libio_is_open_files_in_fs+0x50>
int rtems_libio_is_open_files_in_fs(
rtems_filesystem_mount_table_entry_t * fs_mt_entry
)
{
rtems_libio_t *iop;
int result = 0;
ffc0f7d8: 3b a0 00 00 li r29,0
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
ffc0f7dc: 80 7e 27 f8 lwz r3,10232(r30)
ffc0f7e0: 4b ff 9d 85 bl ffc09564 <rtems_semaphore_release>
}
rtems_libio_unlock();
return result;
}
ffc0f7e4: 80 01 00 1c lwz r0,28(r1)
ffc0f7e8: 7f a3 eb 78 mr r3,r29
ffc0f7ec: 83 c1 00 10 lwz r30,16(r1)
ffc0f7f0: 7c 08 03 a6 mtlr r0
ffc0f7f4: 83 a1 00 0c lwz r29,12(r1)
ffc0f7f8: 83 e1 00 14 lwz r31,20(r1)
ffc0f7fc: 38 21 00 18 addi r1,r1,24
ffc0f800: 4e 80 00 20 blr
ffc0f804: 80 7e 27 f8 lwz r3,10232(r30)
* Check if this node is under the file system that we
* are trying to dismount.
*/
if ( iop->pathinfo.mt_entry == fs_mt_entry ) {
result = 1;
ffc0f808: 3b a0 00 01 li r29,1
ffc0f80c: 4b ff 9d 59 bl ffc09564 <rtems_semaphore_release>
}
rtems_libio_unlock();
return result;
}
ffc0f810: 80 01 00 1c lwz r0,28(r1)
ffc0f814: 7f a3 eb 78 mr r3,r29
ffc0f818: 83 c1 00 10 lwz r30,16(r1)
ffc0f81c: 7c 08 03 a6 mtlr r0
ffc0f820: 83 a1 00 0c lwz r29,12(r1)
ffc0f824: 83 e1 00 14 lwz r31,20(r1)
ffc0f828: 38 21 00 18 addi r1,r1,24
ffc0f82c: 4e 80 00 20 blr
ffc08c14 <rtems_libio_set_private_env>:
rtems_status_code rtems_libio_set_private_env(void)
{
ffc08c14: 94 21 ff b8 stwu r1,-72(r1)
ffc08c18: 7c 08 02 a6 mflr r0
ffc08c1c: 93 e1 00 44 stw r31,68(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);
ffc08c20: 3f e0 ff c2 lis r31,-62
ffc08c24: 3b ff 67 dc addi r31,r31,26588
free(env);
}
}
rtems_status_code rtems_libio_set_private_env(void)
{
ffc08c28: 90 01 00 4c stw r0,76(r1)
ffc08c2c: 93 c1 00 40 stw r30,64(r1)
ffc08c30: 93 81 00 38 stw r28,56(r1)
ffc08c34: 93 a1 00 3c stw r29,60(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id task_id = rtems_task_self();
ffc08c38: 48 00 3d c1 bl ffc0c9f8 <rtems_task_self>
ffc08c3c: 7c 7e 1b 78 mr r30,r3
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);
ffc08c40: 38 80 00 01 li r4,1
ffc08c44: 7f e3 fb 78 mr r3,r31
ffc08c48: 38 a0 00 00 li r5,0
ffc08c4c: 38 c1 00 1c addi r6,r1,28
ffc08c50: 38 e0 00 00 li r7,0
ffc08c54: 4b ff e5 99 bl ffc071ec <rtems_filesystem_evaluate_path>
if (rv != 0)
ffc08c58: 2f 83 00 00 cmpwi cr7,r3,0
error_1:
rtems_filesystem_freenode(&root_loc);
error_0:
return RTEMS_NO_MEMORY;
ffc08c5c: 38 60 00 1a li r3,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)
ffc08c60: 41 9e 00 24 beq- cr7,ffc08c84 <rtems_libio_set_private_env+0x70><== ALWAYS TAKEN
error_1:
rtems_filesystem_freenode(&root_loc);
error_0:
return RTEMS_NO_MEMORY;
}
ffc08c64: 80 01 00 4c lwz r0,76(r1)
ffc08c68: 83 81 00 38 lwz r28,56(r1)
ffc08c6c: 7c 08 03 a6 mtlr r0
ffc08c70: 83 a1 00 3c lwz r29,60(r1)
ffc08c74: 83 c1 00 40 lwz r30,64(r1)
ffc08c78: 83 e1 00 44 lwz r31,68(r1)
ffc08c7c: 38 21 00 48 addi r1,r1,72
ffc08c80: 4e 80 00 20 blr
rv = rtems_filesystem_evaluate_path("/", 1, 0, &root_loc, 0);
if (rv != 0)
goto error_0;
rv = rtems_filesystem_evaluate_path("/", 1, 0, ¤t_loc, 0);
ffc08c84: 7f e3 fb 78 mr r3,r31
ffc08c88: 38 80 00 01 li r4,1
ffc08c8c: 38 a0 00 00 li r5,0
ffc08c90: 38 c1 00 08 addi r6,r1,8
ffc08c94: 38 e0 00 00 li r7,0
ffc08c98: 4b ff e5 55 bl ffc071ec <rtems_filesystem_evaluate_path>
if (rv != 0)
ffc08c9c: 2f 83 00 00 cmpwi cr7,r3,0
ffc08ca0: 40 9e 00 d8 bne- cr7,ffc08d78 <rtems_libio_set_private_env+0x164><== 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
ffc08ca4: 3f 80 00 00 lis r28,0
ffc08ca8: 83 fc 27 5c lwz r31,10076(r28)
/*
* Bharath: I'm not sure if the check can be reduced to
* if( rtems_current_user_env->task_id != task_id ) {
*/
if (
ffc08cac: 3f a0 00 00 lis r29,0
ffc08cb0: 3b bd 2b 70 addi r29,r29,11120
ffc08cb4: 7f 9f e8 00 cmpw cr7,r31,r29
ffc08cb8: 41 9e 00 10 beq- cr7,ffc08cc8 <rtems_libio_set_private_env+0xb4>
rtems_current_user_env == &rtems_global_user_env
|| rtems_current_user_env->task_id != task_id
ffc08cbc: 80 1f 00 00 lwz r0,0(r31)
ffc08cc0: 7f 80 f0 00 cmpw cr7,r0,r30
ffc08cc4: 41 9e 00 38 beq- cr7,ffc08cfc <rtems_libio_set_private_env+0xe8>
) {
new_env = malloc(sizeof(rtems_user_env_t));
ffc08cc8: 38 60 00 48 li r3,72
ffc08ccc: 4b ff f1 39 bl ffc07e04 <malloc>
if (new_env == NULL)
ffc08cd0: 7c 7f 1b 79 mr. r31,r3
ffc08cd4: 41 82 00 9c beq- ffc08d70 <rtems_libio_set_private_env+0x15c>
#ifdef HAVE_USERENV_REFCNT
new_env->refcnt = 1;
#endif
sc = rtems_task_variable_add(
ffc08cd8: 3c a0 ff c1 lis r5,-63
ffc08cdc: 38 60 00 00 li r3,0
ffc08ce0: 38 9c 27 5c addi r4,r28,10076
ffc08ce4: 38 a5 8b c4 addi r5,r5,-29756
ffc08ce8: 48 00 3e 3d bl ffc0cb24 <rtems_task_variable_add>
RTEMS_SELF,
(void*)&rtems_current_user_env,
(void(*)(void *))free_user_env
);
if (sc != RTEMS_SUCCESSFUL)
ffc08cec: 2f 83 00 00 cmpwi cr7,r3,0
ffc08cf0: 40 9e 00 78 bne- cr7,ffc08d68 <rtems_libio_set_private_env+0x154>
goto error_3;
rtems_current_user_env = new_env;
ffc08cf4: 3d 20 00 00 lis r9,0
ffc08cf8: 93 e9 27 5c stw r31,10076(r9)
}
/* Inherit the global values */
*rtems_current_user_env = rtems_global_user_env;
ffc08cfc: 7f e3 fb 78 mr r3,r31
ffc08d00: 7f a4 eb 78 mr r4,r29
ffc08d04: 38 a0 00 48 li r5,72
ffc08d08: 48 00 ea 61 bl ffc17768 <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;
ffc08d0c: 80 01 00 1c lwz r0,28(r1)
}
/* Inherit the global values */
*rtems_current_user_env = rtems_global_user_env;
rtems_current_user_env->task_id = task_id;
ffc08d10: 93 df 00 00 stw r30,0(r31)
* be freed when deleting the environment.
*/
rtems_filesystem_root = root_loc;
rtems_filesystem_current = current_loc;
return RTEMS_SUCCESSFUL;
ffc08d14: 38 60 00 00 li r3,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;
ffc08d18: 90 1f 00 18 stw r0,24(r31)
ffc08d1c: 80 01 00 20 lwz r0,32(r1)
ffc08d20: 90 1f 00 1c stw r0,28(r31)
ffc08d24: 80 01 00 24 lwz r0,36(r1)
ffc08d28: 90 1f 00 20 stw r0,32(r31)
ffc08d2c: 80 01 00 28 lwz r0,40(r1)
ffc08d30: 90 1f 00 24 stw r0,36(r31)
ffc08d34: 80 01 00 2c lwz r0,44(r1)
ffc08d38: 90 1f 00 28 stw r0,40(r31)
rtems_filesystem_current = current_loc;
ffc08d3c: 80 01 00 08 lwz r0,8(r1)
ffc08d40: 90 1f 00 04 stw r0,4(r31)
ffc08d44: 80 01 00 0c lwz r0,12(r1)
ffc08d48: 90 1f 00 08 stw r0,8(r31)
ffc08d4c: 80 01 00 10 lwz r0,16(r1)
ffc08d50: 90 1f 00 0c stw r0,12(r31)
ffc08d54: 80 01 00 14 lwz r0,20(r1)
ffc08d58: 90 1f 00 10 stw r0,16(r31)
ffc08d5c: 80 01 00 18 lwz r0,24(r1)
ffc08d60: 90 1f 00 14 stw r0,20(r31)
return RTEMS_SUCCESSFUL;
ffc08d64: 4b ff ff 00 b ffc08c64 <rtems_libio_set_private_env+0x50>
error_3:
free(new_env);
ffc08d68: 7f e3 fb 78 mr r3,r31
ffc08d6c: 4b ff e7 8d bl ffc074f8 <free>
error_2:
rtems_filesystem_freenode(¤t_loc);
ffc08d70: 38 61 00 08 addi r3,r1,8
ffc08d74: 4b ff e7 59 bl ffc074cc <rtems_filesystem_freenode>
error_1:
rtems_filesystem_freenode(&root_loc);
ffc08d78: 38 61 00 1c addi r3,r1,28
ffc08d7c: 4b ff e7 51 bl ffc074cc <rtems_filesystem_freenode>
error_0:
return RTEMS_NO_MEMORY;
}
ffc08d80: 80 01 00 4c lwz r0,76(r1)
error_1:
rtems_filesystem_freenode(&root_loc);
error_0:
return RTEMS_NO_MEMORY;
ffc08d84: 38 60 00 1a li r3,26
}
ffc08d88: 83 81 00 38 lwz r28,56(r1)
ffc08d8c: 7c 08 03 a6 mtlr r0
ffc08d90: 83 a1 00 3c lwz r29,60(r1)
ffc08d94: 83 c1 00 40 lwz r30,64(r1)
ffc08d98: 83 e1 00 44 lwz r31,68(r1)
ffc08d9c: 38 21 00 48 addi r1,r1,72
ffc08da0: 4e 80 00 20 blr
ffc08da4 <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)
{
ffc08da4: 94 21 ff d8 stwu r1,-40(r1)
ffc08da8: 7c 08 02 a6 mflr r0
ffc08dac: 93 81 00 18 stw r28,24(r1)
ffc08db0: 7c 7c 1b 78 mr r28,r3
ffc08db4: 93 a1 00 1c stw r29,28(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;
ffc08db8: 3b a0 00 00 li r29,0
* 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)
{
ffc08dbc: 93 e1 00 24 stw r31,36(r1)
ffc08dc0: 90 01 00 2c stw r0,44(r1)
ffc08dc4: 93 c1 00 20 stw r30,32(r1)
rtems_id current_task_id;
/*
* get current task id
*/
current_task_id = rtems_task_self();
ffc08dc8: 48 00 3c 31 bl ffc0c9f8 <rtems_task_self>
/*
* 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 )
ffc08dcc: 7f 9c 18 00 cmpw cr7,r28,r3
rtems_id current_task_id;
/*
* get current task id
*/
current_task_id = rtems_task_self();
ffc08dd0: 7c 7f 1b 78 mr r31,r3
/*
* 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 )
ffc08dd4: 41 9e 00 38 beq- cr7,ffc08e0c <rtems_libio_share_private_env+0x68><== NEVER TAKEN
return RTEMS_SUCCESSFUL;
/*
* Try to get the requested user environment
*/
sc = rtems_task_variable_get(
ffc08dd8: 3f c0 00 00 lis r30,0
ffc08ddc: 7f 83 e3 78 mr r3,r28
ffc08de0: 38 9e 27 5c addi r4,r30,10076
ffc08de4: 38 a1 00 08 addi r5,r1,8
ffc08de8: 48 00 3e 39 bl ffc0cc20 <rtems_task_variable_get>
(void*)&shared_user_env );
/*
* If it was not successful, return the error code
*/
if (sc != RTEMS_SUCCESSFUL)
ffc08dec: 7c 7d 1b 79 mr. r29,r3
ffc08df0: 40 82 00 1c bne- ffc08e0c <rtems_libio_share_private_env+0x68>
* 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) {
ffc08df4: 80 7e 27 5c lwz r3,10076(r30)
ffc08df8: 80 03 00 00 lwz r0,0(r3)
ffc08dfc: 7f 80 f8 00 cmpw cr7,r0,r31
ffc08e00: 41 9e 00 30 beq- cr7,ffc08e30 <rtems_libio_share_private_env+0x8c>
rtems_user_env_t *tmp = rtems_current_user_env;
free_user_env( tmp );
}
/* the current_user_env is the same pointer that remote env */
rtems_current_user_env = shared_user_env;
ffc08e04: 80 01 00 08 lwz r0,8(r1)
ffc08e08: 90 1e 27 5c stw r0,10076(r30)
#ifdef HAVE_USERENV_REFCNT
rtems_current_user_env->refcnt++;
#endif
return RTEMS_SUCCESSFUL;
}
ffc08e0c: 80 01 00 2c lwz r0,44(r1)
ffc08e10: 7f a3 eb 78 mr r3,r29
ffc08e14: 83 81 00 18 lwz r28,24(r1)
ffc08e18: 7c 08 03 a6 mtlr r0
ffc08e1c: 83 a1 00 1c lwz r29,28(r1)
ffc08e20: 83 c1 00 20 lwz r30,32(r1)
ffc08e24: 83 e1 00 24 lwz r31,36(r1)
ffc08e28: 38 21 00 28 addi r1,r1,40
ffc08e2c: 4e 80 00 20 blr
* shared_user_env
*/
if (rtems_current_user_env->task_id==current_task_id) {
rtems_user_env_t *tmp = rtems_current_user_env;
free_user_env( tmp );
ffc08e30: 4b ff fd 95 bl ffc08bc4 <free_user_env>
ffc08e34: 4b ff ff d0 b ffc08e04 <rtems_libio_share_private_env+0x60>
ffc0f5d0 <rtems_libio_to_fcntl_flags>:
uint32_t flags
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
ffc0f5d0: 54 60 07 7c rlwinm r0,r3,0,29,30
ffc0f5d4: 2f 80 00 06 cmpwi cr7,r0,6
fcntl_flags |= O_RDWR;
ffc0f5d8: 38 00 00 02 li r0,2
uint32_t flags
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
ffc0f5dc: 41 9e 00 10 beq- cr7,ffc0f5ec <rtems_libio_to_fcntl_flags+0x1c>
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
ffc0f5e0: 70 60 00 02 andi. r0,r3,2
fcntl_flags |= O_RDONLY;
ffc0f5e4: 38 00 00 00 li r0,0
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
ffc0f5e8: 41 82 00 30 beq- ffc0f618 <rtems_libio_to_fcntl_flags+0x48><== NEVER TAKEN
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 ) {
ffc0f5ec: 70 69 00 01 andi. r9,r3,1
ffc0f5f0: 41 82 00 08 beq- ffc0f5f8 <rtems_libio_to_fcntl_flags+0x28>
fcntl_flags |= O_NONBLOCK;
ffc0f5f4: 60 00 40 00 ori r0,r0,16384
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
ffc0f5f8: 70 69 02 00 andi. r9,r3,512
ffc0f5fc: 41 82 00 08 beq- ffc0f604 <rtems_libio_to_fcntl_flags+0x34>
fcntl_flags |= O_APPEND;
ffc0f600: 60 00 00 08 ori r0,r0,8
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
ffc0f604: 70 69 04 00 andi. r9,r3,1024
ffc0f608: 41 82 00 08 beq- ffc0f610 <rtems_libio_to_fcntl_flags+0x40>
fcntl_flags |= O_CREAT;
ffc0f60c: 60 00 02 00 ori r0,r0,512
}
return fcntl_flags;
}
ffc0f610: 7c 03 03 78 mr r3,r0
ffc0f614: 4e 80 00 20 blr
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
ffc0f618: 54 60 f7 fe rlwinm r0,r3,30,31,31 <== NOT EXECUTED
ffc0f61c: 4b ff ff d0 b ffc0f5ec <rtems_libio_to_fcntl_flags+0x1c><== NOT EXECUTED
ffc08b60 <rtems_malloc_statistics_at_free>:
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
ffc08b60: 94 21 ff e8 stwu r1,-24(r1)
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
ffc08b64: 3d 20 00 00 lis r9,0
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
ffc08b68: 7c 08 02 a6 mflr r0
ffc08b6c: 7c 64 1b 78 mr r4,r3
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
ffc08b70: 80 69 27 90 lwz r3,10128(r9)
ffc08b74: 38 a1 00 08 addi r5,r1,8
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
ffc08b78: 90 01 00 1c stw r0,28(r1)
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
ffc08b7c: 48 00 78 51 bl ffc103cc <_Protected_heap_Get_block_size>
ffc08b80: 2f 83 00 00 cmpwi cr7,r3,0
ffc08b84: 41 9e 00 2c beq- cr7,ffc08bb0 <rtems_malloc_statistics_at_free+0x50><== NEVER TAKEN
MSBUMP(lifetime_freed, size);
ffc08b88: 3c e0 00 00 lis r7,0
ffc08b8c: 81 61 00 08 lwz r11,8(r1)
ffc08b90: 38 e7 34 68 addi r7,r7,13416
ffc08b94: 81 07 00 28 lwz r8,40(r7)
ffc08b98: 39 40 00 00 li r10,0
ffc08b9c: 81 27 00 2c lwz r9,44(r7)
ffc08ba0: 7d 6b 48 14 addc r11,r11,r9
ffc08ba4: 7d 4a 41 14 adde r10,r10,r8
ffc08ba8: 91 47 00 28 stw r10,40(r7)
ffc08bac: 91 67 00 2c stw r11,44(r7)
}
}
ffc08bb0: 80 01 00 1c lwz r0,28(r1)
ffc08bb4: 38 21 00 18 addi r1,r1,24
ffc08bb8: 7c 08 03 a6 mtlr r0
ffc08bbc: 4e 80 00 20 blr
ffc08bc0 <rtems_malloc_statistics_at_malloc>:
{
uintptr_t actual_size = 0;
uint32_t current_depth;
rtems_malloc_statistics_t *s = &rtems_malloc_statistics;
if ( !pointer )
ffc08bc0: 7c 64 1b 79 mr. r4,r3
}
static void rtems_malloc_statistics_at_malloc(
void *pointer
)
{
ffc08bc4: 94 21 ff e8 stwu r1,-24(r1)
ffc08bc8: 7c 08 02 a6 mflr r0
ffc08bcc: 90 01 00 1c stw r0,28(r1)
uintptr_t actual_size = 0;
ffc08bd0: 38 00 00 00 li r0,0
ffc08bd4: 90 01 00 08 stw r0,8(r1)
uint32_t current_depth;
rtems_malloc_statistics_t *s = &rtems_malloc_statistics;
if ( !pointer )
ffc08bd8: 41 82 00 54 beq- ffc08c2c <rtems_malloc_statistics_at_malloc+0x6c><== NEVER TAKEN
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
ffc08bdc: 3d 20 00 00 lis r9,0
ffc08be0: 80 69 27 90 lwz r3,10128(r9)
ffc08be4: 38 a1 00 08 addi r5,r1,8
ffc08be8: 48 00 77 e5 bl ffc103cc <_Protected_heap_Get_block_size>
MSBUMP(lifetime_allocated, actual_size);
ffc08bec: 3c e0 00 00 lis r7,0
ffc08bf0: 38 e7 34 68 addi r7,r7,13416
ffc08bf4: 81 61 00 08 lwz r11,8(r1)
ffc08bf8: 81 27 00 24 lwz r9,36(r7)
ffc08bfc: 39 40 00 00 li r10,0
ffc08c00: 81 07 00 20 lwz r8,32(r7)
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
ffc08c04: 80 07 00 2c lwz r0,44(r7)
if ( !pointer )
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
MSBUMP(lifetime_allocated, actual_size);
ffc08c08: 7d 6b 48 14 addc r11,r11,r9
ffc08c0c: 7d 4a 41 14 adde r10,r10,r8
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
if (current_depth > s->max_depth)
ffc08c10: 81 27 00 18 lwz r9,24(r7)
if ( !pointer )
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
MSBUMP(lifetime_allocated, actual_size);
ffc08c14: 91 47 00 20 stw r10,32(r7)
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
ffc08c18: 7c 00 58 50 subf r0,r0,r11
if (current_depth > s->max_depth)
ffc08c1c: 7f 80 48 40 cmplw cr7,r0,r9
if ( !pointer )
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
MSBUMP(lifetime_allocated, actual_size);
ffc08c20: 91 67 00 24 stw r11,36(r7)
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
if (current_depth > s->max_depth)
ffc08c24: 40 9d 00 08 ble- cr7,ffc08c2c <rtems_malloc_statistics_at_malloc+0x6c>
s->max_depth = current_depth;
ffc08c28: 90 07 00 18 stw r0,24(r7)
}
ffc08c2c: 80 01 00 1c lwz r0,28(r1)
ffc08c30: 38 21 00 18 addi r1,r1,24
ffc08c34: 7c 08 03 a6 mtlr r0
ffc08c38: 4e 80 00 20 blr
ffc14128 <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
ffc14128: 94 21 ff e8 stwu r1,-24(r1)
ffc1412c: 7c 08 02 a6 mflr r0
ffc14130: 93 e1 00 14 stw r31,20(r1)
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
ffc14134: 7c 7f 1b 79 mr. r31,r3
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
ffc14138: 93 81 00 08 stw r28,8(r1)
ffc1413c: 7c bc 2b 78 mr r28,r5
ffc14140: 93 a1 00 0c stw r29,12(r1)
/*
* Parameter error checks
*/
if ( !pointer )
return EINVAL;
ffc14144: 3b a0 00 16 li r29,22
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
ffc14148: 93 c1 00 10 stw r30,16(r1)
ffc1414c: 7c 9e 23 78 mr r30,r4
ffc14150: 90 01 00 1c stw r0,28(r1)
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
ffc14154: 41 82 00 6c beq- ffc141c0 <rtems_memalign+0x98>
*pointer = NULL;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
ffc14158: 3d 20 00 00 lis r9,0
ffc1415c: 80 09 28 40 lwz r0,10304(r9)
ffc14160: 2f 80 00 03 cmpwi cr7,r0,3
* Parameter error checks
*/
if ( !pointer )
return EINVAL;
*pointer = NULL;
ffc14164: 38 00 00 00 li r0,0
ffc14168: 90 1f 00 00 stw r0,0(r31)
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
ffc1416c: 41 9e 00 78 beq- cr7,ffc141e4 <rtems_memalign+0xbc> <== ALWAYS TAKEN
return EINVAL;
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
ffc14170: 4b ff 1e 3d bl ffc05fac <malloc_deferred_frees_process>
Heap_Control *heap,
uintptr_t size,
uintptr_t alignment
)
{
return
ffc14174: 3d 20 00 00 lis r9,0
ffc14178: 80 69 27 2c lwz r3,10028(r9)
ffc1417c: 7f c5 f3 78 mr r5,r30
ffc14180: 7f 84 e3 78 mr r4,r28
ffc14184: 38 c0 00 00 li r6,0
ffc14188: 4b ff 84 fd bl ffc0c684 <_Protected_heap_Allocate_aligned_with_boundary>
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
return ENOMEM;
ffc1418c: 3b a0 00 0c li r29,12
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
ffc14190: 7c 7e 1b 79 mr. r30,r3
ffc14194: 41 82 00 2c beq- ffc141c0 <rtems_memalign+0x98>
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
ffc14198: 3d 20 00 00 lis r9,0
ffc1419c: 81 29 27 ac lwz r9,10156(r9)
ffc141a0: 2f 89 00 00 cmpwi cr7,r9,0
ffc141a4: 41 9e 00 14 beq- cr7,ffc141b8 <rtems_memalign+0x90>
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
ffc141a8: 80 09 00 04 lwz r0,4(r9)
ffc141ac: 7f e3 fb 78 mr r3,r31
ffc141b0: 7c 09 03 a6 mtctr r0
ffc141b4: 4e 80 04 21 bctrl
*pointer = return_this;
ffc141b8: 93 df 00 00 stw r30,0(r31)
return 0;
ffc141bc: 3b a0 00 00 li r29,0
}
ffc141c0: 80 01 00 1c lwz r0,28(r1)
ffc141c4: 7f a3 eb 78 mr r3,r29
ffc141c8: 83 81 00 08 lwz r28,8(r1)
ffc141cc: 7c 08 03 a6 mtlr r0
ffc141d0: 83 a1 00 0c lwz r29,12(r1)
ffc141d4: 83 c1 00 10 lwz r30,16(r1)
ffc141d8: 83 e1 00 14 lwz r31,20(r1)
ffc141dc: 38 21 00 18 addi r1,r1,24
ffc141e0: 4e 80 00 20 blr
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() )
ffc141e4: 4b ff 1d 81 bl ffc05f64 <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()) &&
ffc141e8: 2f 83 00 00 cmpwi cr7,r3,0
ffc141ec: 40 be ff 84 bne- cr7,ffc14170 <rtems_memalign+0x48> <== ALWAYS TAKEN
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
*pointer = return_this;
return 0;
}
ffc141f0: 80 01 00 1c lwz r0,28(r1) <== NOT EXECUTED
ffc141f4: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc141f8: 83 81 00 08 lwz r28,8(r1) <== NOT EXECUTED
ffc141fc: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc14200: 83 a1 00 0c lwz r29,12(r1) <== NOT EXECUTED
ffc14204: 83 c1 00 10 lwz r30,16(r1) <== NOT EXECUTED
ffc14208: 83 e1 00 14 lwz r31,20(r1) <== NOT EXECUTED
ffc1420c: 38 21 00 18 addi r1,r1,24 <== NOT EXECUTED
ffc14210: 4e 80 00 20 blr <== NOT EXECUTED
ffc12478 <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
ffc12478: 94 21 ff 88 stwu r1,-120(r1)
ffc1247c: 7d 80 00 26 mfcr r12
ffc12480: 7c 08 02 a6 mflr r0
ffc12484: 93 61 00 64 stw r27,100(r1)
ffc12488: 7c 9b 23 78 mr r27,r4
ffc1248c: 93 c1 00 70 stw r30,112(r1)
ffc12490: 90 01 00 7c stw r0,124(r1)
ffc12494: 93 21 00 5c stw r25,92(r1)
ffc12498: 93 41 00 60 stw r26,96(r1)
ffc1249c: 93 81 00 68 stw r28,104(r1)
ffc124a0: 93 a1 00 6c stw r29,108(r1)
ffc124a4: 93 e1 00 74 stw r31,116(r1)
ffc124a8: 91 81 00 58 stw r12,88(r1)
int success = 0;
char *dup_path = strdup(path);
ffc124ac: 48 00 46 5d bl ffc16b08 <strdup>
if (dup_path != NULL) {
ffc124b0: 7c 7e 1b 79 mr. r30,r3
success = build(dup_path, mode);
free(dup_path);
}
return success != 0 ? 0 : -1;
ffc124b4: 38 60 ff ff li r3,-1
rtems_mkdir(const char *path, mode_t mode)
{
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
ffc124b8: 41 82 01 2c beq- ffc125e4 <rtems_mkdir+0x16c> <== NEVER TAKEN
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
ffc124bc: 88 1e 00 00 lbz r0,0(r30)
ffc124c0: 7f df f3 78 mr r31,r30
ffc124c4: 2f 80 00 2f cmpwi cr7,r0,47
ffc124c8: 41 9e 01 60 beq- cr7,ffc12628 <rtems_mkdir+0x1b0>
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
ffc124cc: 2f 80 00 00 cmpwi cr7,r0,0
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
ffc124d0: 3b a0 00 00 li r29,0
ffc124d4: 39 20 00 01 li r9,1
retval = 0;
break;
}
}
if (!last)
*p = '/';
ffc124d8: 3b 80 00 2f li r28,47
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
last = 1;
else if (p[0] != '/')
continue;
*p = '\0';
ffc124dc: 3b 40 00 00 li r26,0
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
ffc124e0: 41 9e 00 18 beq- cr7,ffc124f8 <rtems_mkdir+0x80> <== NEVER TAKEN
last = 1;
else if (p[0] != '/')
ffc124e4: 2f 80 00 2f cmpwi cr7,r0,47
ffc124e8: 41 9e 00 ac beq- cr7,ffc12594 <rtems_mkdir+0x11c>
retval = 0;
break;
}
}
if (!last)
*p = '/';
ffc124ec: 8c 1f 00 01 lbzu r0,1(r31)
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
ffc124f0: 2f 80 00 00 cmpwi cr7,r0,0
ffc124f4: 40 be ff f0 bne- cr7,ffc124e4 <rtems_mkdir+0x6c>
else if (p[0] != '/')
continue;
*p = '\0';
if (!last && p[1] == '\0')
last = 1;
if (first) {
ffc124f8: 2f 89 00 00 cmpwi cr7,r9,0
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
last = 1;
else if (p[0] != '/')
continue;
*p = '\0';
ffc124fc: 98 1f 00 00 stb r0,0(r31)
ffc12500: 3b 20 00 01 li r25,1
if (!last && p[1] == '\0')
last = 1;
if (first) {
ffc12504: 41 be 00 a8 beq+ cr7,ffc125ac <rtems_mkdir+0x134>
oumask = umask(0);
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
ffc12508: 2e 19 00 00 cmpwi cr4,r25,0
* mkdir [-m mode] dir
*
* We change the user's umask and then restore it,
* instead of doing chmod's.
*/
oumask = umask(0);
ffc1250c: 38 60 00 00 li r3,0
ffc12510: 48 00 02 29 bl ffc12738 <umask>
ffc12514: 7c 7d 1b 78 mr r29,r3
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
ffc12518: 54 63 06 ae rlwinm r3,r3,0,26,23
ffc1251c: 48 00 02 1d bl ffc12738 <umask>
first = 0;
}
if (last)
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
ffc12520: 38 80 01 ff li r4,511
oumask = umask(0);
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
ffc12524: 41 b2 00 94 beq+ cr4,ffc125b8 <rtems_mkdir+0x140>
(void)umask(oumask);
ffc12528: 7f a3 eb 78 mr r3,r29
ffc1252c: 48 00 02 0d bl ffc12738 <umask>
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
ffc12530: 7f 64 db 78 mr r4,r27
ffc12534: 7f c3 f3 78 mr r3,r30
ffc12538: 4b ff 49 35 bl ffc06e6c <mkdir>
ffc1253c: 2f 83 00 00 cmpwi cr7,r3,0
ffc12540: 40 bc 00 88 bge+ cr7,ffc125c8 <rtems_mkdir+0x150>
if (errno == EEXIST || errno == EISDIR) {
ffc12544: 48 00 33 59 bl ffc1589c <__errno>
ffc12548: 80 03 00 00 lwz r0,0(r3)
ffc1254c: 2f 80 00 11 cmpwi cr7,r0,17
ffc12550: 41 9e 00 14 beq- cr7,ffc12564 <rtems_mkdir+0xec>
ffc12554: 48 00 33 49 bl ffc1589c <__errno>
ffc12558: 80 03 00 00 lwz r0,0(r3)
ffc1255c: 2f 80 00 15 cmpwi cr7,r0,21
ffc12560: 40 9e 01 18 bne- cr7,ffc12678 <rtems_mkdir+0x200> <== ALWAYS TAKEN
if (stat(path, &sb) < 0) {
ffc12564: 7f c3 f3 78 mr r3,r30
ffc12568: 38 81 00 08 addi r4,r1,8
ffc1256c: 48 00 01 15 bl ffc12680 <stat>
ffc12570: 2f 83 00 00 cmpwi cr7,r3,0
ffc12574: 41 9c 01 04 blt- cr7,ffc12678 <rtems_mkdir+0x200> <== NEVER TAKEN
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
ffc12578: 80 01 00 14 lwz r0,20(r1)
ffc1257c: 54 00 04 26 rlwinm r0,r0,0,16,19
ffc12580: 2f 80 40 00 cmpwi cr7,r0,16384
ffc12584: 40 9e 00 b0 bne- cr7,ffc12634 <rtems_mkdir+0x1bc>
else
errno = ENOTDIR;
retval = 0;
break;
}
if (last)
ffc12588: 41 92 00 90 beq- cr4,ffc12618 <rtems_mkdir+0x1a0>
retval = 2;
ffc1258c: 3b e0 00 02 li r31,2
ffc12590: 48 00 00 40 b ffc125d0 <rtems_mkdir+0x158>
else if (p[0] != '/')
continue;
*p = '\0';
if (!last && p[1] == '\0')
last = 1;
if (first) {
ffc12594: 2f 89 00 00 cmpwi cr7,r9,0
if (p[0] == '\0')
last = 1;
else if (p[0] != '/')
continue;
*p = '\0';
if (!last && p[1] == '\0')
ffc12598: 8b 3f 00 01 lbz r25,1(r31)
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
last = 1;
else if (p[0] != '/')
continue;
*p = '\0';
ffc1259c: 9b 5f 00 00 stb r26,0(r31)
if (!last && p[1] == '\0')
ffc125a0: 7f 39 00 34 cntlzw r25,r25
ffc125a4: 57 39 d9 7e rlwinm r25,r25,27,5,31
last = 1;
if (first) {
ffc125a8: 40 be ff 60 bne- cr7,ffc12508 <rtems_mkdir+0x90>
oumask = umask(0);
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
ffc125ac: 2e 19 00 00 cmpwi cr4,r25,0
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
ffc125b0: 38 80 01 ff li r4,511
oumask = umask(0);
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
ffc125b4: 40 b2 ff 74 bne- cr4,ffc12528 <rtems_mkdir+0xb0>
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
ffc125b8: 7f c3 f3 78 mr r3,r30
ffc125bc: 4b ff 48 b1 bl ffc06e6c <mkdir>
ffc125c0: 2f 83 00 00 cmpwi cr7,r3,0
ffc125c4: 41 bc ff 80 blt- cr7,ffc12544 <rtems_mkdir+0xcc>
} else {
retval = 0;
break;
}
}
if (!last)
ffc125c8: 41 92 00 50 beq- cr4,ffc12618 <rtems_mkdir+0x1a0>
ffc125cc: 3b e0 00 01 li r31,1
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
ffc125d0: 7f c3 f3 78 mr r3,r30
ffc125d4: 4b ff 3f 71 bl ffc06544 <free>
}
return success != 0 ? 0 : -1;
ffc125d8: 2f 9f 00 00 cmpwi cr7,r31,0
ffc125dc: 38 60 00 00 li r3,0
ffc125e0: 41 9e 00 90 beq- cr7,ffc12670 <rtems_mkdir+0x1f8> <== NEVER TAKEN
}
ffc125e4: 80 01 00 7c lwz r0,124(r1)
ffc125e8: 81 81 00 58 lwz r12,88(r1)
ffc125ec: 7c 08 03 a6 mtlr r0
ffc125f0: 83 21 00 5c lwz r25,92(r1)
ffc125f4: 83 41 00 60 lwz r26,96(r1)
ffc125f8: 7d 80 81 20 mtcrf 8,r12
ffc125fc: 83 61 00 64 lwz r27,100(r1)
ffc12600: 83 81 00 68 lwz r28,104(r1)
ffc12604: 83 a1 00 6c lwz r29,108(r1)
ffc12608: 83 c1 00 70 lwz r30,112(r1)
ffc1260c: 83 e1 00 74 lwz r31,116(r1)
ffc12610: 38 21 00 78 addi r1,r1,120
ffc12614: 4e 80 00 20 blr
retval = 0;
break;
}
}
if (!last)
*p = '/';
ffc12618: 9b 9f 00 00 stb r28,0(r31)
ffc1261c: 39 20 00 00 li r9,0
ffc12620: 8c 1f 00 01 lbzu r0,1(r31)
ffc12624: 4b ff fe cc b ffc124f0 <rtems_mkdir+0x78>
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
ffc12628: 88 1e 00 01 lbz r0,1(r30)
ffc1262c: 3b fe 00 01 addi r31,r30,1
ffc12630: 4b ff fe 9c b ffc124cc <rtems_mkdir+0x54>
if (errno == EEXIST || errno == EISDIR) {
if (stat(path, &sb) < 0) {
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
if (last)
ffc12634: 41 92 00 20 beq- cr4,ffc12654 <rtems_mkdir+0x1dc>
errno = EEXIST;
ffc12638: 48 00 32 65 bl ffc1589c <__errno>
ffc1263c: 38 00 00 11 li r0,17
ffc12640: 90 03 00 00 stw r0,0(r3)
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
ffc12644: 7f c3 f3 78 mr r3,r30
ffc12648: 4b ff 3e fd bl ffc06544 <free>
}
return success != 0 ? 0 : -1;
ffc1264c: 38 60 ff ff li r3,-1
ffc12650: 4b ff ff 94 b ffc125e4 <rtems_mkdir+0x16c>
break;
} else if (!S_ISDIR(sb.st_mode)) {
if (last)
errno = EEXIST;
else
errno = ENOTDIR;
ffc12654: 48 00 32 49 bl ffc1589c <__errno>
ffc12658: 38 00 00 14 li r0,20
ffc1265c: 90 03 00 00 stw r0,0(r3)
}
if (!last)
*p = '/';
}
if (!first && !last)
(void)umask(oumask);
ffc12660: 7f a3 eb 78 mr r3,r29
ffc12664: 48 00 00 d5 bl ffc12738 <umask>
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
ffc12668: 7f c3 f3 78 mr r3,r30
ffc1266c: 4b ff 3e d9 bl ffc06544 <free>
}
return success != 0 ? 0 : -1;
ffc12670: 38 60 ff ff li r3,-1
ffc12674: 4b ff ff 70 b ffc125e4 <rtems_mkdir+0x16c>
}
}
if (!last)
*p = '/';
}
if (!first && !last)
ffc12678: 41 92 ff e8 beq+ cr4,ffc12660 <rtems_mkdir+0x1e8> <== NEVER TAKEN
ffc1267c: 4b ff ff ec b ffc12668 <rtems_mkdir+0x1f0>
ffc0b05c <rtems_object_get_class_information>:
rtems_status_code rtems_object_get_class_information(
int the_api,
int the_class,
rtems_object_api_class_information *info
)
{
ffc0b05c: 94 21 ff f0 stwu r1,-16(r1)
ffc0b060: 7c 08 02 a6 mflr r0
ffc0b064: 93 e1 00 0c stw r31,12(r1)
int i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
ffc0b068: 7c bf 2b 79 mr. r31,r5
rtems_status_code rtems_object_get_class_information(
int the_api,
int the_class,
rtems_object_api_class_information *info
)
{
ffc0b06c: 90 01 00 14 stw r0,20(r1)
/*
* Validate parameters and look up information structure.
*/
if ( !info )
return RTEMS_INVALID_ADDRESS;
ffc0b070: 38 00 00 09 li r0,9
int i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
ffc0b074: 41 82 00 7c beq- ffc0b0f0 <rtems_object_get_class_information+0x94>
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
ffc0b078: 54 84 04 3e clrlwi r4,r4,16
ffc0b07c: 48 00 24 a5 bl ffc0d520 <_Objects_Get_information>
if ( !obj_info )
return RTEMS_INVALID_NUMBER;
ffc0b080: 38 00 00 0a li r0,10
*/
if ( !info )
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
if ( !obj_info )
ffc0b084: 2c 03 00 00 cmpwi r3,0
ffc0b088: 41 82 00 68 beq- ffc0b0f0 <rtems_object_get_class_information+0x94>
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
ffc0b08c: a1 03 00 10 lhz r8,16(r3)
return RTEMS_INVALID_NUMBER;
/*
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
ffc0b090: 80 03 00 08 lwz r0,8(r3)
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
ffc0b094: 2f 88 00 00 cmpwi cr7,r8,0
/*
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
ffc0b098: 81 63 00 0c lwz r11,12(r3)
info->auto_extend = obj_info->auto_extend;
ffc0b09c: 89 23 00 12 lbz r9,18(r3)
return RTEMS_INVALID_NUMBER;
/*
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
ffc0b0a0: 90 1f 00 00 stw r0,0(r31)
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
ffc0b0a4: 38 00 00 00 li r0,0
/*
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
ffc0b0a8: 91 7f 00 04 stw r11,4(r31)
info->auto_extend = obj_info->auto_extend;
ffc0b0ac: 99 3f 00 0c stb r9,12(r31)
info->maximum = obj_info->maximum;
ffc0b0b0: 91 1f 00 08 stw r8,8(r31)
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
ffc0b0b4: 41 9e 00 34 beq- cr7,ffc0b0e8 <rtems_object_get_class_information+0x8c><== NEVER TAKEN
ffc0b0b8: 80 e3 00 1c lwz r7,28(r3)
ffc0b0bc: 39 60 00 01 li r11,1
ffc0b0c0: 39 20 00 01 li r9,1
ffc0b0c4: 39 29 00 01 addi r9,r9,1
ffc0b0c8: 7f 88 48 40 cmplw cr7,r8,r9
if ( !obj_info->local_table[i] )
ffc0b0cc: 55 6b 10 3a rlwinm r11,r11,2,0,29
ffc0b0d0: 7d 47 58 2e lwzx r10,r7,r11
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
ffc0b0d4: 7d 2b 4b 78 mr r11,r9
if ( !obj_info->local_table[i] )
unallocated++;
ffc0b0d8: 20 ca 00 00 subfic r6,r10,0
ffc0b0dc: 7c c0 01 94 addze r6,r0
ffc0b0e0: 7c c0 33 78 mr r0,r6
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
ffc0b0e4: 40 9c ff e0 bge+ cr7,ffc0b0c4 <rtems_object_get_class_information+0x68>
if ( !obj_info->local_table[i] )
unallocated++;
info->unallocated = unallocated;
ffc0b0e8: 90 1f 00 10 stw r0,16(r31)
return RTEMS_SUCCESSFUL;
ffc0b0ec: 38 00 00 00 li r0,0
}
ffc0b0f0: 7c 03 03 78 mr r3,r0
ffc0b0f4: 80 01 00 14 lwz r0,20(r1)
ffc0b0f8: 83 e1 00 0c lwz r31,12(r1)
ffc0b0fc: 38 21 00 10 addi r1,r1,16
ffc0b100: 7c 08 03 a6 mtlr r0
ffc0b104: 4e 80 00 20 blr
ffc04ecc <rtems_panic>:
void rtems_panic(
const char *printf_format,
...
)
{
ffc04ecc: 94 21 ff 88 stwu r1,-120(r1)
ffc04ed0: 7c 08 02 a6 mflr r0
ffc04ed4: 90 81 00 1c stw r4,28(r1)
ffc04ed8: 90 01 00 7c stw r0,124(r1)
ffc04edc: 90 a1 00 20 stw r5,32(r1)
ffc04ee0: 90 c1 00 24 stw r6,36(r1)
ffc04ee4: 90 e1 00 28 stw r7,40(r1)
ffc04ee8: 91 01 00 2c stw r8,44(r1)
ffc04eec: 91 21 00 30 stw r9,48(r1)
ffc04ef0: 91 41 00 34 stw r10,52(r1)
ffc04ef4: 40 86 00 24 bne- cr1,ffc04f18 <rtems_panic+0x4c> <== ALWAYS TAKEN
ffc04ef8: d8 21 00 38 stfd f1,56(r1) <== NOT EXECUTED
ffc04efc: d8 41 00 40 stfd f2,64(r1) <== NOT EXECUTED
ffc04f00: d8 61 00 48 stfd f3,72(r1) <== NOT EXECUTED
ffc04f04: d8 81 00 50 stfd f4,80(r1) <== NOT EXECUTED
ffc04f08: d8 a1 00 58 stfd f5,88(r1) <== NOT EXECUTED
ffc04f0c: d8 c1 00 60 stfd f6,96(r1) <== NOT EXECUTED
ffc04f10: d8 e1 00 68 stfd f7,104(r1) <== NOT EXECUTED
ffc04f14: d9 01 00 70 stfd f8,112(r1) <== NOT EXECUTED
va_list arglist;
va_start(arglist, printf_format);
ffc04f18: 38 00 00 01 li r0,1
ffc04f1c: 98 01 00 08 stb r0,8(r1)
ffc04f20: 38 00 00 00 li r0,0
void rtems_panic(
const char *printf_format,
...
)
{
ffc04f24: 7c 64 1b 78 mr r4,r3
va_list arglist;
va_start(arglist, printf_format);
ffc04f28: 98 01 00 09 stb r0,9(r1)
ffc04f2c: 38 01 00 80 addi r0,r1,128
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
ffc04f30: 38 a1 00 08 addi r5,r1,8
...
)
{
va_list arglist;
va_start(arglist, printf_format);
ffc04f34: 90 01 00 0c stw r0,12(r1)
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
ffc04f38: 3c 60 20 00 lis r3,8192
...
)
{
va_list arglist;
va_start(arglist, printf_format);
ffc04f3c: 38 01 00 18 addi r0,r1,24
ffc04f40: 90 01 00 10 stw r0,16(r1)
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
ffc04f44: 4b ff fc f9 bl ffc04c3c <rtems_verror>
va_end(arglist);
rtems_error(0, "fatal error, exiting");
ffc04f48: 3c 80 ff c2 lis r4,-62
ffc04f4c: 38 84 08 a8 addi r4,r4,2216
ffc04f50: 38 60 00 00 li r3,0
ffc04f54: 4c c6 31 82 crclr 4*cr1+eq
ffc04f58: 4b ff fe 9d bl ffc04df4 <rtems_error>
_exit(errno);
ffc04f5c: 48 00 ee 31 bl ffc13d8c <__errno>
ffc04f60: 80 63 00 00 lwz r3,0(r3)
ffc04f64: 48 00 0d a5 bl ffc05d08 <_exit>
ffc19120 <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
ffc19120: 94 21 ff d0 stwu r1,-48(r1)
ffc19124: 7c 08 02 a6 mflr r0
ffc19128: 93 e1 00 2c stw r31,44(r1)
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
ffc1912c: 7c 7f 1b 79 mr. r31,r3
return RTEMS_INVALID_NAME;
ffc19130: 38 60 00 03 li r3,3
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
ffc19134: 93 c1 00 28 stw r30,40(r1)
ffc19138: 7c be 2b 78 mr r30,r5
ffc1913c: 90 01 00 34 stw r0,52(r1)
ffc19140: 93 61 00 1c stw r27,28(r1)
ffc19144: 93 81 00 20 stw r28,32(r1)
ffc19148: 93 a1 00 24 stw r29,36(r1)
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
ffc1914c: 40 82 00 28 bne- ffc19174 <rtems_partition_create+0x54>
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
ffc19150: 80 01 00 34 lwz r0,52(r1)
ffc19154: 83 61 00 1c lwz r27,28(r1)
ffc19158: 7c 08 03 a6 mtlr r0
ffc1915c: 83 81 00 20 lwz r28,32(r1)
ffc19160: 83 a1 00 24 lwz r29,36(r1)
ffc19164: 83 c1 00 28 lwz r30,40(r1)
ffc19168: 83 e1 00 2c lwz r31,44(r1)
ffc1916c: 38 21 00 30 addi r1,r1,48
ffc19170: 4e 80 00 20 blr
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !starting_address )
ffc19174: 2f 84 00 00 cmpwi cr7,r4,0
return RTEMS_INVALID_ADDRESS;
ffc19178: 38 60 00 09 li r3,9
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !starting_address )
ffc1917c: 41 be ff d4 beq- cr7,ffc19150 <rtems_partition_create+0x30>
return RTEMS_INVALID_ADDRESS;
if ( !id )
ffc19180: 2f 88 00 00 cmpwi cr7,r8,0
ffc19184: 41 be ff cc beq- cr7,ffc19150 <rtems_partition_create+0x30><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
ffc19188: 2f 85 00 00 cmpwi cr7,r5,0
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
ffc1918c: 38 60 00 08 li r3,8
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
ffc19190: 41 9e ff c0 beq+ cr7,ffc19150 <rtems_partition_create+0x30>
ffc19194: 2f 86 00 00 cmpwi cr7,r6,0
ffc19198: 41 9e ff b8 beq+ cr7,ffc19150 <rtems_partition_create+0x30>
ffc1919c: 7f 85 30 40 cmplw cr7,r5,r6
ffc191a0: 41 9c ff b0 blt+ cr7,ffc19150 <rtems_partition_create+0x30>
ffc191a4: 70 c0 00 07 andi. r0,r6,7
ffc191a8: 40 82 ff a8 bne+ ffc19150 <rtems_partition_create+0x30>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
ffc191ac: 70 9b 00 07 andi. r27,r4,7
return RTEMS_INVALID_ADDRESS;
ffc191b0: 38 60 00 09 li r3,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 ) )
ffc191b4: 40 82 ff 9c bne+ ffc19150 <rtems_partition_create+0x30>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc191b8: 3d 20 00 00 lis r9,0
ffc191bc: 80 09 28 e0 lwz r0,10464(r9)
ffc191c0: 30 00 00 01 addic r0,r0,1
ffc191c4: 90 09 28 e0 stw r0,10464(r9)
return _Thread_Dispatch_disable_level;
ffc191c8: 80 09 28 e0 lwz r0,10464(r9)
* 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 );
ffc191cc: 3f 80 00 00 lis r28,0
ffc191d0: 90 81 00 08 stw r4,8(r1)
ffc191d4: 3b 9c 6f 20 addi r28,r28,28448
ffc191d8: 7f 83 e3 78 mr r3,r28
ffc191dc: 90 c1 00 0c stw r6,12(r1)
ffc191e0: 90 e1 00 10 stw r7,16(r1)
ffc191e4: 91 01 00 14 stw r8,20(r1)
ffc191e8: 48 00 60 a9 bl ffc1f290 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
ffc191ec: 7c 7d 1b 79 mr. r29,r3
ffc191f0: 80 81 00 08 lwz r4,8(r1)
ffc191f4: 80 c1 00 0c lwz r6,12(r1)
ffc191f8: 80 e1 00 10 lwz r7,16(r1)
ffc191fc: 81 01 00 14 lwz r8,20(r1)
ffc19200: 41 82 00 50 beq- ffc19250 <rtems_partition_create+0x130>
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,
ffc19204: 7c be 33 96 divwu r5,r30,r6
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
ffc19208: 90 9d 00 10 stw r4,16(r29)
the_partition->length = length;
the_partition->buffer_size = buffer_size;
ffc1920c: 90 dd 00 18 stw r6,24(r29)
the_partition->attribute_set = attribute_set;
ffc19210: 90 fd 00 1c stw r7,28(r29)
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
the_partition->length = length;
ffc19214: 93 dd 00 14 stw r30,20(r29)
the_partition->buffer_size = buffer_size;
the_partition->attribute_set = attribute_set;
the_partition->number_of_used_blocks = 0;
ffc19218: 93 7d 00 20 stw r27,32(r29)
_Chain_Initialize( &the_partition->Memory, starting_address,
ffc1921c: 91 01 00 14 stw r8,20(r1)
ffc19220: 38 7d 00 24 addi r3,r29,36
ffc19224: 48 00 42 41 bl ffc1d464 <_Chain_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
ffc19228: 80 1d 00 08 lwz r0,8(r29)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
ffc1922c: 81 7c 00 1c lwz r11,28(r28)
ffc19230: 54 09 13 ba rlwinm r9,r0,2,14,29
ffc19234: 7f ab 49 2e stwx r29,r11,r9
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
ffc19238: 93 fd 00 0c stw r31,12(r29)
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
ffc1923c: 81 01 00 14 lwz r8,20(r1)
ffc19240: 90 08 00 00 stw r0,0(r8)
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
ffc19244: 48 00 77 5d bl ffc209a0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
ffc19248: 38 60 00 00 li r3,0
ffc1924c: 4b ff ff 04 b ffc19150 <rtems_partition_create+0x30>
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
_Thread_Enable_dispatch();
ffc19250: 48 00 77 51 bl ffc209a0 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
ffc19254: 38 60 00 05 li r3,5
ffc19258: 4b ff fe f8 b ffc19150 <rtems_partition_create+0x30>
ffc193e8 <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
rtems_id id,
void *buffer
)
{
ffc193e8: 94 21 ff e0 stwu r1,-32(r1)
ffc193ec: 7c 08 02 a6 mflr r0
ffc193f0: 90 01 00 24 stw r0,36(r1)
ffc193f4: 7c 60 1b 78 mr r0,r3
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
ffc193f8: 3c 60 00 00 lis r3,0
ffc193fc: 93 e1 00 1c stw r31,28(r1)
ffc19400: 38 63 6f 20 addi r3,r3,28448
ffc19404: 7c 9f 23 78 mr r31,r4
ffc19408: 38 a1 00 08 addi r5,r1,8
ffc1940c: 93 c1 00 18 stw r30,24(r1)
ffc19410: 7c 04 03 78 mr r4,r0
ffc19414: 48 00 64 ad bl ffc1f8c0 <_Objects_Get>
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
ffc19418: 80 01 00 08 lwz r0,8(r1)
ffc1941c: 7c 7e 1b 78 mr r30,r3
ffc19420: 2f 80 00 00 cmpwi cr7,r0,0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
ffc19424: 38 60 00 04 li r3,4
{
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
ffc19428: 40 9e 00 58 bne- cr7,ffc19480 <rtems_partition_return_buffer+0x98>
)
{
void *starting;
void *ending;
starting = the_partition->starting_address;
ffc1942c: 80 1e 00 10 lwz r0,16(r30)
ending = _Addresses_Add_offset( starting, the_partition->length );
ffc19430: 81 3e 00 14 lwz r9,20(r30)
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
ffc19434: 7f 9f 00 40 cmplw cr7,r31,r0
ffc19438: 41 9c 00 60 blt- cr7,ffc19498 <rtems_partition_return_buffer+0xb0>
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
ffc1943c: 7d 20 4a 14 add r9,r0,r9
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
ffc19440: 7f 9f 48 40 cmplw cr7,r31,r9
ffc19444: 41 9d 00 54 bgt- cr7,ffc19498 <rtems_partition_return_buffer+0xb0><== NEVER TAKEN
offset = (uint32_t) _Addresses_Subtract(
the_buffer,
the_partition->starting_address
);
return ((offset % the_partition->buffer_size) == 0);
ffc19448: 81 3e 00 18 lwz r9,24(r30)
RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract (
const void *left,
const void *right
)
{
return (int32_t) ((const char *) left - (const char *) right);
ffc1944c: 7c 00 f8 50 subf r0,r0,r31
ffc19450: 7d 60 4b 96 divwu r11,r0,r9
ffc19454: 7d 2b 49 d6 mullw r9,r11,r9
starting = the_partition->starting_address;
ending = _Addresses_Add_offset( starting, the_partition->length );
return (
_Addresses_Is_in_range( the_buffer, starting, ending ) &&
ffc19458: 7f 80 48 00 cmpw cr7,r0,r9
ffc1945c: 40 9e 00 3c bne- cr7,ffc19498 <rtems_partition_return_buffer+0xb0>
RTEMS_INLINE_ROUTINE void _Partition_Free_buffer (
Partition_Control *the_partition,
Chain_Node *the_buffer
)
{
_Chain_Append( &the_partition->Memory, the_buffer );
ffc19460: 38 7e 00 24 addi r3,r30,36
ffc19464: 7f e4 fb 78 mr r4,r31
ffc19468: 48 00 3f 65 bl ffc1d3cc <_Chain_Append>
case OBJECTS_LOCAL:
if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) {
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
ffc1946c: 81 3e 00 20 lwz r9,32(r30)
ffc19470: 38 09 ff ff addi r0,r9,-1
ffc19474: 90 1e 00 20 stw r0,32(r30)
_Thread_Enable_dispatch();
ffc19478: 48 00 75 29 bl ffc209a0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
ffc1947c: 38 60 00 00 li r3,0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
ffc19480: 80 01 00 24 lwz r0,36(r1)
ffc19484: 83 c1 00 18 lwz r30,24(r1)
ffc19488: 7c 08 03 a6 mtlr r0
ffc1948c: 83 e1 00 1c lwz r31,28(r1)
ffc19490: 38 21 00 20 addi r1,r1,32
ffc19494: 4e 80 00 20 blr
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
ffc19498: 48 00 75 09 bl ffc209a0 <_Thread_Enable_dispatch>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
ffc1949c: 80 01 00 24 lwz r0,36(r1)
the_partition->number_of_used_blocks -= 1;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
return RTEMS_INVALID_ADDRESS;
ffc194a0: 38 60 00 09 li r3,9
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
ffc194a4: 83 c1 00 18 lwz r30,24(r1)
ffc194a8: 7c 08 03 a6 mtlr r0
ffc194ac: 83 e1 00 1c lwz r31,28(r1)
ffc194b0: 38 21 00 20 addi r1,r1,32
ffc194b4: 4e 80 00 20 blr
ffc0a2e8 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
ffc0a2e8: 94 21 ff d0 stwu r1,-48(r1)
ffc0a2ec: 7c 08 02 a6 mflr r0
ffc0a2f0: 93 e1 00 2c stw r31,44(r1)
ffc0a2f4: 7c 7f 1b 78 mr r31,r3
RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
ffc0a2f8: 3c 60 00 00 lis r3,0
ffc0a2fc: 93 c1 00 28 stw r30,40(r1)
ffc0a300: 38 63 2c 98 addi r3,r3,11416
ffc0a304: 7c 9e 23 78 mr r30,r4
ffc0a308: 38 a1 00 08 addi r5,r1,8
ffc0a30c: 90 01 00 34 stw r0,52(r1)
ffc0a310: 7f e4 fb 78 mr r4,r31
ffc0a314: 93 a1 00 24 stw r29,36(r1)
ffc0a318: 93 61 00 1c stw r27,28(r1)
ffc0a31c: 93 81 00 20 stw r28,32(r1)
ffc0a320: 48 00 2d c9 bl ffc0d0e8 <_Objects_Get>
ffc0a324: 7c 7d 1b 78 mr r29,r3
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
ffc0a328: 80 01 00 08 lwz r0,8(r1)
ffc0a32c: 2f 80 00 00 cmpwi cr7,r0,0
ffc0a330: 40 9e 00 4c bne- cr7,ffc0a37c <rtems_rate_monotonic_period+0x94>
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
ffc0a334: 3f 80 00 00 lis r28,0
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
ffc0a338: 81 23 00 40 lwz r9,64(r3)
ffc0a33c: 3b 9c 32 44 addi r28,r28,12868
ffc0a340: 80 1c 00 0c lwz r0,12(r28)
ffc0a344: 7f 89 00 00 cmpw cr7,r9,r0
ffc0a348: 41 9e 00 60 beq- cr7,ffc0a3a8 <rtems_rate_monotonic_period+0xc0>
_Thread_Enable_dispatch();
ffc0a34c: 48 00 3e 7d bl ffc0e1c8 <_Thread_Enable_dispatch>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
ffc0a350: 80 01 00 34 lwz r0,52(r1)
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
ffc0a354: 3b e0 00 17 li r31,23
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
ffc0a358: 83 61 00 1c lwz r27,28(r1)
ffc0a35c: 7c 08 03 a6 mtlr r0
ffc0a360: 7f e3 fb 78 mr r3,r31
ffc0a364: 83 81 00 20 lwz r28,32(r1)
ffc0a368: 83 a1 00 24 lwz r29,36(r1)
ffc0a36c: 83 c1 00 28 lwz r30,40(r1)
ffc0a370: 83 e1 00 2c lwz r31,44(r1)
ffc0a374: 38 21 00 30 addi r1,r1,48
ffc0a378: 4e 80 00 20 blr
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
ffc0a37c: 3b e0 00 04 li r31,4
}
ffc0a380: 80 01 00 34 lwz r0,52(r1)
ffc0a384: 7f e3 fb 78 mr r3,r31
ffc0a388: 83 61 00 1c lwz r27,28(r1)
ffc0a38c: 7c 08 03 a6 mtlr r0
ffc0a390: 83 81 00 20 lwz r28,32(r1)
ffc0a394: 83 a1 00 24 lwz r29,36(r1)
ffc0a398: 83 c1 00 28 lwz r30,40(r1)
ffc0a39c: 83 e1 00 2c lwz r31,44(r1)
ffc0a3a0: 38 21 00 30 addi r1,r1,48
ffc0a3a4: 4e 80 00 20 blr
if ( !_Thread_Is_executing( the_period->owner ) ) {
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
ffc0a3a8: 2f 9e 00 00 cmpwi cr7,r30,0
ffc0a3ac: 41 9e 00 80 beq- cr7,ffc0a42c <rtems_rate_monotonic_period+0x144>
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0a3b0: 7f 60 00 a6 mfmsr r27
ffc0a3b4: 7c 10 42 a6 mfsprg r0,0
ffc0a3b8: 7f 60 00 78 andc r0,r27,r0
ffc0a3bc: 7c 00 01 24 mtmsr r0
_Thread_Enable_dispatch();
return( return_value );
}
_ISR_Disable( level );
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
ffc0a3c0: 80 03 00 38 lwz r0,56(r3)
ffc0a3c4: 2f 80 00 00 cmpwi cr7,r0,0
ffc0a3c8: 41 9e 00 8c beq- cr7,ffc0a454 <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 ) {
ffc0a3cc: 2f 80 00 02 cmpwi cr7,r0,2
ffc0a3d0: 41 9e 00 d4 beq- cr7,ffc0a4a4 <rtems_rate_monotonic_period+0x1bc>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
ffc0a3d4: 2f 80 00 04 cmpwi cr7,r0,4
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
ffc0a3d8: 3b e0 00 04 li r31,4
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
ffc0a3dc: 40 9e ff a4 bne+ cr7,ffc0a380 <rtems_rate_monotonic_period+0x98><== NEVER TAKEN
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
ffc0a3e0: 4b ff fd e1 bl ffc0a1c0 <_Rate_monotonic_Update_statistics>
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0a3e4: 7f 60 01 24 mtmsr r27
_ISR_Enable( level );
the_period->state = RATE_MONOTONIC_ACTIVE;
ffc0a3e8: 38 00 00 02 li r0,2
the_period->next_length = length;
ffc0a3ec: 93 dd 00 3c stw r30,60(r29)
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
ffc0a3f0: 3c 60 00 00 lis r3,0
*/
_Rate_monotonic_Update_statistics( the_period );
_ISR_Enable( level );
the_period->state = RATE_MONOTONIC_ACTIVE;
ffc0a3f4: 90 1d 00 38 stw r0,56(r29)
ffc0a3f8: 38 63 2e 68 addi r3,r3,11880
ffc0a3fc: 38 9d 00 10 addi r4,r29,16
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
ffc0a400: 93 dd 00 1c stw r30,28(r29)
the_period->next_length = length;
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Scheduler_Release_job(the_period->owner, the_period->next_length);
_Thread_Enable_dispatch();
return RTEMS_TIMEOUT;
ffc0a404: 3b e0 00 06 li r31,6
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
ffc0a408: 48 00 51 ed bl ffc0f5f4 <_Watchdog_Insert>
ffc0a40c: 3d 20 00 00 lis r9,0
ffc0a410: 80 09 21 14 lwz r0,8468(r9)
ffc0a414: 80 7d 00 40 lwz r3,64(r29)
ffc0a418: 80 9d 00 3c lwz r4,60(r29)
ffc0a41c: 7c 09 03 a6 mtctr r0
ffc0a420: 4e 80 04 21 bctrl
the_period->state = RATE_MONOTONIC_ACTIVE;
the_period->next_length = length;
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Scheduler_Release_job(the_period->owner, the_period->next_length);
_Thread_Enable_dispatch();
ffc0a424: 48 00 3d a5 bl ffc0e1c8 <_Thread_Enable_dispatch>
return RTEMS_TIMEOUT;
ffc0a428: 4b ff ff 58 b ffc0a380 <rtems_rate_monotonic_period+0x98>
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
switch ( the_period->state ) {
ffc0a42c: 80 03 00 38 lwz r0,56(r3)
ffc0a430: 3b e0 00 00 li r31,0
ffc0a434: 2b 80 00 04 cmplwi cr7,r0,4
ffc0a438: 41 9d 00 14 bgt- cr7,ffc0a44c <rtems_rate_monotonic_period+0x164><== NEVER TAKEN
ffc0a43c: 3d 20 ff c2 lis r9,-62
ffc0a440: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc0a444: 39 29 2c 98 addi r9,r9,11416
ffc0a448: 7f e9 00 2e lwzx r31,r9,r0
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
ffc0a44c: 48 00 3d 7d bl ffc0e1c8 <_Thread_Enable_dispatch>
return( return_value );
ffc0a450: 4b ff ff 30 b ffc0a380 <rtems_rate_monotonic_period+0x98>
ffc0a454: 7f 60 01 24 mtmsr r27
_ISR_Disable( level );
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
_ISR_Enable( level );
the_period->next_length = length;
ffc0a458: 93 c3 00 3c stw r30,60(r3)
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
ffc0a45c: 4b ff fc 91 bl ffc0a0ec <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
ffc0a460: 39 20 00 02 li r9,2
ffc0a464: 91 3d 00 38 stw r9,56(r29)
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
ffc0a468: 3d 20 ff c1 lis r9,-63
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
ffc0a46c: 38 00 00 00 li r0,0
the_watchdog->routine = routine;
ffc0a470: 39 29 a8 c8 addi r9,r9,-22328
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
ffc0a474: 90 1d 00 18 stw r0,24(r29)
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
ffc0a478: 3c 60 00 00 lis r3,0
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
ffc0a47c: 91 3d 00 2c stw r9,44(r29)
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
ffc0a480: 38 63 2e 68 addi r3,r3,11880
ffc0a484: 38 9d 00 10 addi r4,r29,16
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
the_watchdog->id = id;
ffc0a488: 93 fd 00 30 stw r31,48(r29)
NULL
);
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
ffc0a48c: 3b e0 00 00 li r31,0
the_watchdog->user_data = user_data;
ffc0a490: 90 1d 00 34 stw r0,52(r29)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
ffc0a494: 93 dd 00 1c stw r30,28(r29)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
ffc0a498: 48 00 51 5d bl ffc0f5f4 <_Watchdog_Insert>
id,
NULL
);
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
ffc0a49c: 48 00 3d 2d bl ffc0e1c8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
ffc0a4a0: 4b ff fe e0 b ffc0a380 <rtems_rate_monotonic_period+0x98>
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
ffc0a4a4: 4b ff fd 1d bl ffc0a1c0 <_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;
ffc0a4a8: 38 00 00 01 li r0,1
ffc0a4ac: 90 1d 00 38 stw r0,56(r29)
the_period->next_length = length;
ffc0a4b0: 93 dd 00 3c stw r30,60(r29)
ffc0a4b4: 7f 60 01 24 mtmsr r27
_ISR_Enable( level );
_Thread_Executing->Wait.id = the_period->Object.id;
ffc0a4b8: 81 3c 00 0c lwz r9,12(r28)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
ffc0a4bc: 38 80 40 00 li r4,16384
the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;
the_period->next_length = length;
_ISR_Enable( level );
_Thread_Executing->Wait.id = the_period->Object.id;
ffc0a4c0: 80 1d 00 08 lwz r0,8(r29)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
ffc0a4c4: 7d 23 4b 78 mr r3,r9
the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;
the_period->next_length = length;
_ISR_Enable( level );
_Thread_Executing->Wait.id = the_period->Object.id;
ffc0a4c8: 90 09 00 20 stw r0,32(r9)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
ffc0a4cc: 48 00 47 fd bl ffc0ecc8 <_Thread_Set_state>
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0a4d0: 7d 20 00 a6 mfmsr r9
ffc0a4d4: 7c 10 42 a6 mfsprg r0,0
ffc0a4d8: 7d 20 00 78 andc r0,r9,r0
ffc0a4dc: 7c 00 01 24 mtmsr r0
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
local_state = the_period->state;
the_period->state = RATE_MONOTONIC_ACTIVE;
ffc0a4e0: 39 60 00 02 li r11,2
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
local_state = the_period->state;
ffc0a4e4: 80 1d 00 38 lwz r0,56(r29)
the_period->state = RATE_MONOTONIC_ACTIVE;
ffc0a4e8: 91 7d 00 38 stw r11,56(r29)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0a4ec: 7d 20 01 24 mtmsr r9
/*
* 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 )
ffc0a4f0: 2f 80 00 03 cmpwi cr7,r0,3
ffc0a4f4: 41 9e 00 10 beq- cr7,ffc0a504 <rtems_rate_monotonic_period+0x21c><== NEVER TAKEN
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
_Thread_Enable_dispatch();
ffc0a4f8: 48 00 3c d1 bl ffc0e1c8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
ffc0a4fc: 3b e0 00 00 li r31,0
ffc0a500: 4b ff fe 80 b ffc0a380 <rtems_rate_monotonic_period+0x98>
/*
* 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 )
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
ffc0a504: 80 7c 00 0c lwz r3,12(r28) <== NOT EXECUTED
ffc0a508: 38 80 40 00 li r4,16384 <== NOT EXECUTED
ffc0a50c: 48 00 38 35 bl ffc0dd40 <_Thread_Clear_state> <== NOT EXECUTED
ffc0a510: 4b ff ff e8 b ffc0a4f8 <rtems_rate_monotonic_period+0x210><== NOT EXECUTED
ffc0a514 <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
ffc0a514: 94 21 ff 70 stwu r1,-144(r1)
ffc0a518: 7c 08 02 a6 mflr r0
ffc0a51c: 90 01 00 94 stw r0,148(r1)
rtems_id id;
rtems_rate_monotonic_period_statistics the_stats;
rtems_rate_monotonic_period_status the_status;
char name[5];
if ( !print )
ffc0a520: 7c 80 23 79 mr. r0,r4
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
ffc0a524: 93 a1 00 84 stw r29,132(r1)
ffc0a528: 7c 7d 1b 78 mr r29,r3
ffc0a52c: 93 01 00 70 stw r24,112(r1)
ffc0a530: 93 21 00 74 stw r25,116(r1)
ffc0a534: 93 41 00 78 stw r26,120(r1)
ffc0a538: 93 61 00 7c stw r27,124(r1)
ffc0a53c: 93 81 00 80 stw r28,128(r1)
ffc0a540: 93 c1 00 88 stw r30,136(r1)
ffc0a544: 93 e1 00 8c stw r31,140(r1)
rtems_id id;
rtems_rate_monotonic_period_statistics the_stats;
rtems_rate_monotonic_period_status the_status;
char name[5];
if ( !print )
ffc0a548: 90 01 00 68 stw r0,104(r1)
ffc0a54c: 41 82 01 70 beq- ffc0a6bc <rtems_rate_monotonic_report_statistics_with_plugin+0x1a8><== NEVER TAKEN
return;
(*print)( context, "Period information by period\n" );
ffc0a550: 3c 80 ff c2 lis r4,-62
ffc0a554: 7c 09 03 a6 mtctr r0
ffc0a558: 38 84 2c ac addi r4,r4,11436
/*
* 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 ;
ffc0a55c: 3f c0 00 00 lis r30,0
ffc0a560: 3b de 2c 98 addi r30,r30,11416
char name[5];
if ( !print )
return;
(*print)( context, "Period information by period\n" );
ffc0a564: 4c c6 31 82 crclr 4*cr1+eq
ffc0a568: 4e 80 04 21 bctrl
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
ffc0a56c: 80 01 00 68 lwz r0,104(r1)
ffc0a570: 3c 80 ff c2 lis r4,-62
ffc0a574: 7c 09 03 a6 mtctr r0
ffc0a578: 38 84 2c cc addi r4,r4,11468
ffc0a57c: 7f a3 eb 78 mr r3,r29
ffc0a580: 4c c6 31 82 crclr 4*cr1+eq
ffc0a584: 4e 80 04 21 bctrl
(*print)( context, "--- Wall times are in seconds ---\n" );
ffc0a588: 80 01 00 68 lwz r0,104(r1)
ffc0a58c: 3c 80 ff c2 lis r4,-62
ffc0a590: 7c 09 03 a6 mtctr r0
ffc0a594: 38 84 2c f0 addi r4,r4,11504
ffc0a598: 7f a3 eb 78 mr r3,r29
ffc0a59c: 4c c6 31 82 crclr 4*cr1+eq
ffc0a5a0: 4e 80 04 21 bctrl
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
ffc0a5a4: 80 01 00 68 lwz r0,104(r1)
ffc0a5a8: 3c 80 ff c2 lis r4,-62
ffc0a5ac: 7c 09 03 a6 mtctr r0
ffc0a5b0: 38 84 2d 14 addi r4,r4,11540
ffc0a5b4: 7f a3 eb 78 mr r3,r29
ffc0a5b8: 4c c6 31 82 crclr 4*cr1+eq
ffc0a5bc: 4e 80 04 21 bctrl
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
ffc0a5c0: 80 01 00 68 lwz r0,104(r1)
ffc0a5c4: 3c 80 ff c2 lis r4,-62
ffc0a5c8: 7c 09 03 a6 mtctr r0
ffc0a5cc: 7f a3 eb 78 mr r3,r29
ffc0a5d0: 38 84 2d 60 addi r4,r4,11616
ffc0a5d4: 4c c6 31 82 crclr 4*cr1+eq
ffc0a5d8: 4e 80 04 21 bctrl
/*
* 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 ;
ffc0a5dc: 83 fe 00 08 lwz r31,8(r30)
ffc0a5e0: 80 1e 00 0c lwz r0,12(r30)
ffc0a5e4: 7f 9f 00 40 cmplw cr7,r31,r0
ffc0a5e8: 41 9d 00 d4 bgt- cr7,ffc0a6bc <rtems_rate_monotonic_report_statistics_with_plugin+0x1a8><== NEVER TAKEN
rtems_object_get_name( the_status.owner, sizeof(name), name );
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
ffc0a5ec: 3f 40 ff c2 lis r26,-62
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,
ffc0a5f0: 3f 00 ff c2 lis r24,-62
ffc0a5f4: 3f 80 10 62 lis r28,4194
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,
ffc0a5f8: 3f 20 ff c2 lis r25,-62
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
ffc0a5fc: 3f 60 ff c2 lis r27,-62
rtems_object_get_name( the_status.owner, sizeof(name), name );
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
ffc0a600: 3b 5a 2d ac addi r26,r26,11692
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,
ffc0a604: 3b 18 2d c4 addi r24,r24,11716
ffc0a608: 63 9c 4d d3 ori r28,r28,19923
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,
ffc0a60c: 3b 39 2d e4 addi r25,r25,11748
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
ffc0a610: 3b 7b 19 00 addi r27,r27,6400
ffc0a614: 48 00 00 14 b ffc0a628 <rtems_rate_monotonic_report_statistics_with_plugin+0x114>
/*
* 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 ;
ffc0a618: 80 1e 00 0c lwz r0,12(r30)
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
ffc0a61c: 3b ff 00 01 addi r31,r31,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 ;
ffc0a620: 7f 80 f8 40 cmplw cr7,r0,r31
ffc0a624: 41 9c 00 98 blt- cr7,ffc0a6bc <rtems_rate_monotonic_report_statistics_with_plugin+0x1a8>
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
ffc0a628: 7f e3 fb 78 mr r3,r31
ffc0a62c: 38 81 00 30 addi r4,r1,48
ffc0a630: 48 00 80 79 bl ffc126a8 <rtems_rate_monotonic_get_statistics>
if ( status != RTEMS_SUCCESSFUL )
ffc0a634: 2f 83 00 00 cmpwi cr7,r3,0
ffc0a638: 40 9e ff e0 bne+ cr7,ffc0a618 <rtems_rate_monotonic_report_statistics_with_plugin+0x104>
#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 );
ffc0a63c: 38 81 00 18 addi r4,r1,24
ffc0a640: 7f e3 fb 78 mr r3,r31
ffc0a644: 48 00 81 75 bl ffc127b8 <rtems_rate_monotonic_get_status>
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
ffc0a648: 80 61 00 18 lwz r3,24(r1)
ffc0a64c: 38 a1 00 08 addi r5,r1,8
ffc0a650: 38 80 00 05 li r4,5
ffc0a654: 48 00 03 41 bl ffc0a994 <rtems_object_get_name>
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
ffc0a658: 80 01 00 68 lwz r0,104(r1)
ffc0a65c: 7f 44 d3 78 mr r4,r26
ffc0a660: 80 e1 00 30 lwz r7,48(r1)
ffc0a664: 7f e5 fb 78 mr r5,r31
ffc0a668: 7c 09 03 a6 mtctr r0
ffc0a66c: 7f a3 eb 78 mr r3,r29
ffc0a670: 81 01 00 34 lwz r8,52(r1)
ffc0a674: 38 c1 00 08 addi r6,r1,8
ffc0a678: 4c c6 31 82 crclr 4*cr1+eq
ffc0a67c: 4e 80 04 21 bctrl
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
ffc0a680: 80 01 00 30 lwz r0,48(r1)
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 );
ffc0a684: 38 61 00 48 addi r3,r1,72
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
ffc0a688: 2f 80 00 00 cmpwi cr7,r0,0
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 );
ffc0a68c: 38 a1 00 10 addi r5,r1,16
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
ffc0a690: 7f 64 db 78 mr r4,r27
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
ffc0a694: 40 9e 00 58 bne- cr7,ffc0a6ec <rtems_rate_monotonic_report_statistics_with_plugin+0x1d8>
(*print)( context, "\n" );
ffc0a698: 80 01 00 68 lwz r0,104(r1)
ffc0a69c: 7f a3 eb 78 mr r3,r29
* 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++ ) {
ffc0a6a0: 3b ff 00 01 addi r31,r31,1
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
ffc0a6a4: 7c 09 03 a6 mtctr r0
ffc0a6a8: 4c c6 31 82 crclr 4*cr1+eq
ffc0a6ac: 4e 80 04 21 bctrl
/*
* 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 ;
ffc0a6b0: 80 1e 00 0c lwz r0,12(r30)
ffc0a6b4: 7f 80 f8 40 cmplw cr7,r0,r31
ffc0a6b8: 40 9c ff 70 bge+ cr7,ffc0a628 <rtems_rate_monotonic_report_statistics_with_plugin+0x114><== ALWAYS TAKEN
the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall
);
#endif
}
}
}
ffc0a6bc: 80 01 00 94 lwz r0,148(r1)
ffc0a6c0: 83 01 00 70 lwz r24,112(r1)
ffc0a6c4: 7c 08 03 a6 mtlr r0
ffc0a6c8: 83 21 00 74 lwz r25,116(r1)
ffc0a6cc: 83 41 00 78 lwz r26,120(r1)
ffc0a6d0: 83 61 00 7c lwz r27,124(r1)
ffc0a6d4: 83 81 00 80 lwz r28,128(r1)
ffc0a6d8: 83 a1 00 84 lwz r29,132(r1)
ffc0a6dc: 83 c1 00 88 lwz r30,136(r1)
ffc0a6e0: 83 e1 00 8c lwz r31,140(r1)
ffc0a6e4: 38 21 00 90 addi r1,r1,144
ffc0a6e8: 4e 80 00 20 blr
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 );
ffc0a6ec: 7c 04 03 78 mr r4,r0
ffc0a6f0: 48 00 48 dd bl ffc0efcc <_Timespec_Divide_by_integer>
(*print)( context,
ffc0a6f4: 80 01 00 14 lwz r0,20(r1)
ffc0a6f8: 80 81 00 3c lwz r4,60(r1)
ffc0a6fc: 7f a3 eb 78 mr r3,r29
ffc0a700: 81 61 00 44 lwz r11,68(r1)
ffc0a704: 7d 40 e0 96 mulhw r10,r0,r28
ffc0a708: 80 e1 00 40 lwz r7,64(r1)
ffc0a70c: 7c c4 e0 96 mulhw r6,r4,r28
ffc0a710: 81 21 00 10 lwz r9,16(r1)
ffc0a714: 80 a1 00 38 lwz r5,56(r1)
ffc0a718: 7d 0b e0 96 mulhw r8,r11,r28
ffc0a71c: 7c 00 fe 70 srawi r0,r0,31
ffc0a720: 7d 4a 36 70 srawi r10,r10,6
ffc0a724: 7d 40 50 50 subf r10,r0,r10
ffc0a728: 80 01 00 68 lwz r0,104(r1)
ffc0a72c: 7d 6b fe 70 srawi r11,r11,31
ffc0a730: 7c 84 fe 70 srawi r4,r4,31
ffc0a734: 7c 09 03 a6 mtctr r0
ffc0a738: 7c c6 36 70 srawi r6,r6,6
ffc0a73c: 7d 08 36 70 srawi r8,r8,6
ffc0a740: 7c c4 30 50 subf r6,r4,r6
ffc0a744: 7d 0b 40 50 subf r8,r11,r8
ffc0a748: 7f 04 c3 78 mr r4,r24
ffc0a74c: 4c c6 31 82 crclr 4*cr1+eq
ffc0a750: 4e 80 04 21 bctrl
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);
ffc0a754: 80 81 00 30 lwz r4,48(r1)
ffc0a758: 38 61 00 60 addi r3,r1,96
ffc0a75c: 38 a1 00 10 addi r5,r1,16
ffc0a760: 48 00 48 6d bl ffc0efcc <_Timespec_Divide_by_integer>
(*print)( context,
ffc0a764: 80 01 00 14 lwz r0,20(r1)
ffc0a768: 80 c1 00 54 lwz r6,84(r1)
ffc0a76c: 7f a3 eb 78 mr r3,r29
ffc0a770: 81 61 00 5c lwz r11,92(r1)
ffc0a774: 7d 40 e0 96 mulhw r10,r0,r28
ffc0a778: 80 a1 00 50 lwz r5,80(r1)
ffc0a77c: 7d 86 e0 96 mulhw r12,r6,r28
ffc0a780: 80 e1 00 58 lwz r7,88(r1)
ffc0a784: 81 21 00 10 lwz r9,16(r1)
ffc0a788: 7d 0b e0 96 mulhw r8,r11,r28
ffc0a78c: 7c 00 fe 70 srawi r0,r0,31
ffc0a790: 7d 4a 36 70 srawi r10,r10,6
ffc0a794: 7d 40 50 50 subf r10,r0,r10
ffc0a798: 80 01 00 68 lwz r0,104(r1)
ffc0a79c: 7d 8c 36 70 srawi r12,r12,6
ffc0a7a0: 7d 6b fe 70 srawi r11,r11,31
ffc0a7a4: 7c 09 03 a6 mtctr r0
ffc0a7a8: 7c c6 fe 70 srawi r6,r6,31
ffc0a7ac: 7d 08 36 70 srawi r8,r8,6
ffc0a7b0: 7f 24 cb 78 mr r4,r25
ffc0a7b4: 7c c6 60 50 subf r6,r6,r12
ffc0a7b8: 7d 0b 40 50 subf r8,r11,r8
ffc0a7bc: 4c c6 31 82 crclr 4*cr1+eq
ffc0a7c0: 4e 80 04 21 bctrl
ffc0a7c4: 4b ff fe 54 b ffc0a618 <rtems_rate_monotonic_report_statistics_with_plugin+0x104>
ffc0a7d8 <rtems_rate_monotonic_reset_all_statistics>:
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc0a7d8: 3d 20 00 00 lis r9,0
/*
* rtems_rate_monotonic_reset_all_statistics
*/
void rtems_rate_monotonic_reset_all_statistics( void )
{
ffc0a7dc: 94 21 ff f0 stwu r1,-16(r1)
ffc0a7e0: 7c 08 02 a6 mflr r0
ffc0a7e4: 81 69 28 6c lwz r11,10348(r9)
ffc0a7e8: 90 01 00 14 stw r0,20(r1)
ffc0a7ec: 38 0b 00 01 addi r0,r11,1
ffc0a7f0: 90 09 28 6c stw r0,10348(r9)
ffc0a7f4: 93 c1 00 08 stw r30,8(r1)
ffc0a7f8: 93 e1 00 0c stw r31,12(r1)
return _Thread_Dispatch_disable_level;
ffc0a7fc: 80 09 28 6c lwz r0,10348(r9)
/*
* Cycle through all possible ids and try to reset 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 ;
ffc0a800: 3f c0 00 00 lis r30,0
ffc0a804: 3b de 2c 98 addi r30,r30,11416
ffc0a808: 83 fe 00 08 lwz r31,8(r30)
ffc0a80c: 80 1e 00 0c lwz r0,12(r30)
ffc0a810: 7f 9f 00 40 cmplw cr7,r31,r0
ffc0a814: 41 9d 00 1c bgt- cr7,ffc0a830 <rtems_rate_monotonic_reset_all_statistics+0x58><== NEVER TAKEN
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
(void) rtems_rate_monotonic_reset_statistics( id );
ffc0a818: 7f e3 fb 78 mr r3,r31
ffc0a81c: 48 00 00 31 bl ffc0a84c <rtems_rate_monotonic_reset_statistics>
/*
* Cycle through all possible ids and try to reset 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 ;
ffc0a820: 80 1e 00 0c lwz r0,12(r30)
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
ffc0a824: 3b ff 00 01 addi r31,r31,1
/*
* Cycle through all possible ids and try to reset 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 ;
ffc0a828: 7f 80 f8 40 cmplw cr7,r0,r31
ffc0a82c: 40 9c ff ec bge+ cr7,ffc0a818 <rtems_rate_monotonic_reset_all_statistics+0x40>
}
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
ffc0a830: 48 00 39 99 bl ffc0e1c8 <_Thread_Enable_dispatch>
}
ffc0a834: 80 01 00 14 lwz r0,20(r1)
ffc0a838: 83 c1 00 08 lwz r30,8(r1)
ffc0a83c: 7c 08 03 a6 mtlr r0
ffc0a840: 83 e1 00 0c lwz r31,12(r1)
ffc0a844: 38 21 00 10 addi r1,r1,16
ffc0a848: 4e 80 00 20 blr
ffc20e24 <rtems_rfs_bitmap_create_search>:
int
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
{
ffc20e24: 94 21 ff e0 stwu r1,-32(r1)
ffc20e28: 7c 08 02 a6 mflr r0
rtems_rfs_bitmap_map map;
size_t size;
rtems_rfs_bitmap_bit bit;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
ffc20e2c: 38 81 00 08 addi r4,r1,8
return 0;
}
int
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
{
ffc20e30: 93 e1 00 1c stw r31,28(r1)
ffc20e34: 7c 7f 1b 78 mr r31,r3
ffc20e38: 90 01 00 24 stw r0,36(r1)
rtems_rfs_bitmap_map map;
size_t size;
rtems_rfs_bitmap_bit bit;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
ffc20e3c: 4b ff f7 85 bl ffc205c0 <rtems_rfs_bitmap_load_map>
if (rc > 0)
ffc20e40: 2c 03 00 00 cmpwi r3,0
ffc20e44: 40 81 00 18 ble- ffc20e5c <rtems_rfs_bitmap_create_search+0x38><== ALWAYS TAKEN
bit++;
map++;
}
return 0;
}
ffc20e48: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
ffc20e4c: 83 e1 00 1c lwz r31,28(r1) <== NOT EXECUTED
ffc20e50: 38 21 00 20 addi r1,r1,32 <== NOT EXECUTED
ffc20e54: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc20e58: 4e 80 00 20 blr <== NOT EXECUTED
if (rc > 0)
return rc;
control->free = 0;
search_map = control->search_bits;
size = control->size;
ffc20e5c: 81 5f 00 0c lwz r10,12(r31)
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
control->free = 0;
ffc20e60: 38 00 00 00 li r0,0
search_map = control->search_bits;
ffc20e64: 81 9f 00 14 lwz r12,20(r31)
else
bit++;
map++;
}
return 0;
ffc20e68: 38 60 00 00 li r3,0
search_map = control->search_bits;
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
while (size)
ffc20e6c: 2f 8a 00 00 cmpwi cr7,r10,0
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
control->free = 0;
ffc20e70: 90 1f 00 10 stw r0,16(r31)
search_map = control->search_bits;
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
ffc20e74: 38 00 ff ff li r0,-1
ffc20e78: 90 0c 00 00 stw r0,0(r12)
while (size)
ffc20e7c: 41 be ff cc beq- cr7,ffc20e48 <rtems_rfs_bitmap_create_search+0x24><== NEVER TAKEN
ffc20e80: 80 c1 00 08 lwz r6,8(r1)
return rc;
control->free = 0;
search_map = control->search_bits;
size = control->size;
bit = 0;
ffc20e84: 38 a0 00 00 li r5,0
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask (unsigned int size)
{
rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK;
mask >>= (rtems_rfs_bitmap_element_bits () - size);
ffc20e88: 38 60 ff ff li r3,-1
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
ffc20e8c: 39 00 00 01 li r8,1
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
while (size)
{
rtems_rfs_bitmap_element bits;
int available;
if (size < rtems_rfs_bitmap_element_bits ())
ffc20e90: 2b 8a 00 1f cmplwi cr7,r10,31
ffc20e94: 41 9d 00 88 bgt- cr7,ffc20f1c <rtems_rfs_bitmap_create_search+0xf8>
{
/*
* Use the normal bit operators because we do not change the bits just merge
* the 2 separate parts.
*/
bits1 &= mask;
ffc20e98: 80 06 00 00 lwz r0,0(r6)
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask (unsigned int size)
{
rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK;
mask >>= (rtems_rfs_bitmap_element_bits () - size);
ffc20e9c: 21 6a 00 20 subfic r11,r10,32
ffc20ea0: 7c 6b 5c 30 srw r11,r3,r11
{
/*
* Use the normal bit operators because we do not change the bits just merge
* the 2 separate parts.
*/
bits1 &= mask;
ffc20ea4: 7d 6b 00 38 and r11,r11,r0
if (size < rtems_rfs_bitmap_element_bits ())
{
bits = rtems_rfs_bitmap_merge (*map,
RTEMS_RFS_BITMAP_ELEMENT_SET,
rtems_rfs_bitmap_mask_section (0, size));
available = size;
ffc20ea8: 7d 44 53 78 mr r4,r10
ffc20eac: 7d 40 53 78 mr r0,r10
{
bits = *map;
available = rtems_rfs_bitmap_element_bits ();
}
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
ffc20eb0: 2f 8b 00 00 cmpwi cr7,r11,0
ffc20eb4: 41 9e 00 34 beq- cr7,ffc20ee8 <rtems_rfs_bitmap_create_search+0xc4>
ffc20eb8: 2f 80 00 00 cmpwi cr7,r0,0
ffc20ebc: 7c 09 03 a6 mtctr r0
ffc20ec0: 39 20 00 00 li r9,0
ffc20ec4: 40 9d 00 78 ble- cr7,ffc20f3c <rtems_rfs_bitmap_create_search+0x118><== NEVER TAKEN
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
ffc20ec8: 7d 00 48 30 slw r0,r8,r9
rtems_rfs_bitmap_set (*search_map, bit);
else
{
int b;
for (b = 0; b < available; b++)
if (!rtems_rfs_bitmap_test (bits, b))
ffc20ecc: 7c 07 58 39 and. r7,r0,r11
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
rtems_rfs_bitmap_set (*search_map, bit);
else
{
int b;
for (b = 0; b < available; b++)
ffc20ed0: 39 29 00 01 addi r9,r9,1
if (!rtems_rfs_bitmap_test (bits, b))
ffc20ed4: 41 82 00 10 beq- ffc20ee4 <rtems_rfs_bitmap_create_search+0xc0>
control->free++;
ffc20ed8: 80 ff 00 10 lwz r7,16(r31)
ffc20edc: 38 07 00 01 addi r0,r7,1
ffc20ee0: 90 1f 00 10 stw r0,16(r31)
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
rtems_rfs_bitmap_set (*search_map, bit);
else
{
int b;
for (b = 0; b < available; b++)
ffc20ee4: 42 00 ff e4 bdnz+ ffc20ec8 <rtems_rfs_bitmap_create_search+0xa4>
control->free++;
}
size -= available;
if (bit == rtems_rfs_bitmap_element_bits ())
ffc20ee8: 2f 85 00 20 cmpwi cr7,r5,32
for (b = 0; b < available; b++)
if (!rtems_rfs_bitmap_test (bits, b))
control->free++;
}
size -= available;
ffc20eec: 7d 44 50 50 subf r10,r4,r10
if (bit == rtems_rfs_bitmap_element_bits ())
ffc20ef0: 41 9e 00 3c beq- cr7,ffc20f2c <rtems_rfs_bitmap_create_search+0x108><== NEVER TAKEN
bit = 0;
search_map++;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
}
else
bit++;
ffc20ef4: 38 a5 00 01 addi r5,r5,1
search_map = control->search_bits;
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
while (size)
ffc20ef8: 2f 8a 00 00 cmpwi cr7,r10,0
bit = 0;
search_map++;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
}
else
bit++;
ffc20efc: 38 c6 00 04 addi r6,r6,4
search_map = control->search_bits;
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
while (size)
ffc20f00: 40 9e ff 90 bne+ cr7,ffc20e90 <rtems_rfs_bitmap_create_search+0x6c>
bit++;
map++;
}
return 0;
}
ffc20f04: 80 01 00 24 lwz r0,36(r1)
else
bit++;
map++;
}
return 0;
ffc20f08: 38 60 00 00 li r3,0
}
ffc20f0c: 83 e1 00 1c lwz r31,28(r1)
ffc20f10: 38 21 00 20 addi r1,r1,32
ffc20f14: 7c 08 03 a6 mtlr r0
ffc20f18: 4e 80 00 20 blr
rtems_rfs_bitmap_mask_section (0, size));
available = size;
}
else
{
bits = *map;
ffc20f1c: 81 66 00 00 lwz r11,0(r6)
ffc20f20: 38 80 00 20 li r4,32
available = rtems_rfs_bitmap_element_bits ();
ffc20f24: 38 00 00 20 li r0,32
ffc20f28: 4b ff ff 88 b ffc20eb0 <rtems_rfs_bitmap_create_search+0x8c>
if (bit == rtems_rfs_bitmap_element_bits ())
{
bit = 0;
search_map++;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
ffc20f2c: 90 6c 00 04 stw r3,4(r12) <== NOT EXECUTED
size -= available;
if (bit == rtems_rfs_bitmap_element_bits ())
{
bit = 0;
ffc20f30: 38 a0 00 00 li r5,0 <== NOT EXECUTED
search_map++;
ffc20f34: 39 8c 00 04 addi r12,r12,4 <== NOT EXECUTED
ffc20f38: 4b ff ff c0 b ffc20ef8 <rtems_rfs_bitmap_create_search+0xd4><== NOT EXECUTED
ffc20f3c: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc20f40: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc20f44: 4b ff ff 84 b ffc20ec8 <rtems_rfs_bitmap_create_search+0xa4><== NOT EXECUTED
ffc205c0 <rtems_rfs_bitmap_load_map>:
* @return int The error number (errno). No error if 0.
*/
static int
rtems_rfs_bitmap_load_map (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_map* map)
{
ffc205c0: 94 21 ff f0 stwu r1,-16(r1)
ffc205c4: 7c 08 02 a6 mflr r0
ffc205c8: 90 01 00 14 stw r0,20(r1)
int rc;
if (!control->buffer)
ffc205cc: 80 03 00 00 lwz r0,0(r3)
* @return int The error number (errno). No error if 0.
*/
static int
rtems_rfs_bitmap_load_map (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_map* map)
{
ffc205d0: 93 c1 00 08 stw r30,8(r1)
ffc205d4: 7c 9e 23 78 mr r30,r4
int rc;
if (!control->buffer)
ffc205d8: 2f 80 00 00 cmpwi cr7,r0,0
* @return int The error number (errno). No error if 0.
*/
static int
rtems_rfs_bitmap_load_map (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_map* map)
{
ffc205dc: 93 e1 00 0c stw r31,12(r1)
ffc205e0: 7c 7f 1b 78 mr r31,r3
int rc;
if (!control->buffer)
return ENXIO;
ffc205e4: 38 60 00 06 li r3,6
rtems_rfs_bitmap_load_map (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_map* map)
{
int rc;
if (!control->buffer)
ffc205e8: 41 9e 00 38 beq- cr7,ffc20620 <rtems_rfs_bitmap_load_map+0x60><== NEVER TAKEN
return ENXIO;
*map = NULL;
ffc205ec: 38 00 00 00 li r0,0
rc = rtems_rfs_buffer_handle_request (control->fs,
ffc205f0: 80 bf 00 08 lwz r5,8(r31)
int rc;
if (!control->buffer)
return ENXIO;
*map = NULL;
ffc205f4: 90 04 00 00 stw r0,0(r4)
rc = rtems_rfs_buffer_handle_request (control->fs,
ffc205f8: 38 c0 00 01 li r6,1
ffc205fc: 80 7f 00 04 lwz r3,4(r31)
ffc20600: 80 9f 00 00 lwz r4,0(r31)
ffc20604: 48 00 22 51 bl ffc22854 <rtems_rfs_buffer_handle_request>
control->buffer,
control->block,
true);
if (rc)
ffc20608: 2c 03 00 00 cmpwi r3,0
ffc2060c: 40 82 00 14 bne- ffc20620 <rtems_rfs_bitmap_load_map+0x60><== NEVER TAKEN
return rc;
*map = rtems_rfs_buffer_data (control->buffer);
ffc20610: 81 3f 00 00 lwz r9,0(r31)
ffc20614: 81 29 00 08 lwz r9,8(r9)
ffc20618: 80 09 00 24 lwz r0,36(r9)
ffc2061c: 90 1e 00 00 stw r0,0(r30)
return 0;
}
ffc20620: 80 01 00 14 lwz r0,20(r1)
ffc20624: 83 c1 00 08 lwz r30,8(r1)
ffc20628: 7c 08 03 a6 mtlr r0
ffc2062c: 83 e1 00 0c lwz r31,12(r1)
ffc20630: 38 21 00 10 addi r1,r1,16
ffc20634: 4e 80 00 20 blr
ffc20d00 <rtems_rfs_bitmap_map_alloc>:
int
rtems_rfs_bitmap_map_alloc (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit seed,
bool* allocated,
rtems_rfs_bitmap_bit* bit)
{
ffc20d00: 94 21 ff e0 stwu r1,-32(r1)
ffc20d04: 7c 08 02 a6 mflr r0
ffc20d08: 7d 80 00 26 mfcr r12
ffc20d0c: 2d 84 00 00 cmpwi cr3,r4,0
ffc20d10: 90 01 00 24 stw r0,36(r1)
int rc = 0;
/*
* By default we assume the allocation failed.
*/
*allocated = false;
ffc20d14: 38 00 00 00 li r0,0
int
rtems_rfs_bitmap_map_alloc (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit seed,
bool* allocated,
rtems_rfs_bitmap_bit* bit)
{
ffc20d18: 93 61 00 0c stw r27,12(r1)
ffc20d1c: 7c db 33 78 mr r27,r6
ffc20d20: 93 81 00 10 stw r28,16(r1)
ffc20d24: 7c bc 2b 78 mr r28,r5
ffc20d28: 93 a1 00 14 stw r29,20(r1)
ffc20d2c: 7c 7d 1b 78 mr r29,r3
ffc20d30: 93 c1 00 18 stw r30,24(r1)
* seed up then from the seed down a window number of bits, then repeat the
* process from the window distance from the seed, again above then
* below. Keep moving out until all bits have been searched.
*/
upper_seed = seed;
lower_seed = seed;
ffc20d34: 7c 9e 23 78 mr r30,r4
int
rtems_rfs_bitmap_map_alloc (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit seed,
bool* allocated,
rtems_rfs_bitmap_bit* bit)
{
ffc20d38: 93 e1 00 1c stw r31,28(r1)
* of bits from the original seed above then below. That is search from the
* seed up then from the seed down a window number of bits, then repeat the
* process from the window distance from the seed, again above then
* below. Keep moving out until all bits have been searched.
*/
upper_seed = seed;
ffc20d3c: 7c 9f 23 78 mr r31,r4
int
rtems_rfs_bitmap_map_alloc (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit seed,
bool* allocated,
rtems_rfs_bitmap_bit* bit)
{
ffc20d40: 91 81 00 08 stw r12,8(r1)
int rc = 0;
/*
* By default we assume the allocation failed.
*/
*allocated = false;
ffc20d44: 98 05 00 00 stb r0,0(r5)
* we have searched all of the map. The seed may not be aligned to a window
* boundary so we may need to search a partial window and this may also not
* be balanced for the upper or lower seeds. We move to the limits, search
* then return false if no clear bits are found.
*/
while (((upper_seed >= 0) && (upper_seed < control->size))
ffc20d48: 41 8c 00 64 blt- cr3,ffc20dac <rtems_rfs_bitmap_map_alloc+0xac><== NEVER TAKEN
ffc20d4c: 80 1d 00 0c lwz r0,12(r29)
ffc20d50: 7f 9f 00 40 cmplw cr7,r31,r0
ffc20d54: 40 9c 00 58 bge- cr7,ffc20dac <rtems_rfs_bitmap_map_alloc+0xac><== NEVER TAKEN
/*
* Search up first so bits allocated in succession are grouped together.
*/
if (upper_seed < control->size)
{
*bit = upper_seed;
ffc20d58: 93 fb 00 00 stw r31,0(r27)
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
ffc20d5c: 7f a3 eb 78 mr r3,r29
ffc20d60: 7f 64 db 78 mr r4,r27
ffc20d64: 7f 85 e3 78 mr r5,r28
ffc20d68: 38 c0 00 01 li r6,1
ffc20d6c: 4b ff f8 cd bl ffc20638 <rtems_rfs_search_map_for_clear_bit.constprop.1>
window, 1);
if ((rc > 0) || *allocated)
ffc20d70: 2f 83 00 00 cmpwi cr7,r3,0
ffc20d74: 41 9d 00 80 bgt- cr7,ffc20df4 <rtems_rfs_bitmap_map_alloc+0xf4><== NEVER TAKEN
ffc20d78: 88 1c 00 00 lbz r0,0(r28)
ffc20d7c: 2f 80 00 00 cmpwi cr7,r0,0
ffc20d80: 40 9e 00 74 bne- cr7,ffc20df4 <rtems_rfs_bitmap_map_alloc+0xf4><== ALWAYS TAKEN
break;
}
if (lower_seed >= 0)
ffc20d84: 2e 1e 00 00 cmpwi cr4,r30,0 <== NOT EXECUTED
ffc20d88: 40 90 00 40 bge- cr4,ffc20dc8 <rtems_rfs_bitmap_map_alloc+0xc8><== NOT EXECUTED
/*
* Do not bound the limits at the edges of the map. Do not update if an
* edge has been passed.
*/
if (upper_seed < control->size)
ffc20d8c: 80 1d 00 0c lwz r0,12(r29) <== NOT EXECUTED
ffc20d90: 7f 80 f8 40 cmplw cr7,r0,r31 <== NOT EXECUTED
ffc20d94: 40 9d 00 0c ble- cr7,ffc20da0 <rtems_rfs_bitmap_map_alloc+0xa0><== NOT EXECUTED
ffc20d98: 3b ff 08 00 addi r31,r31,2048 <== NOT EXECUTED
ffc20d9c: 2d 9f 00 00 cmpwi cr3,r31,0 <== NOT EXECUTED
upper_seed += window;
if (lower_seed >= 0)
ffc20da0: 41 b0 ff a8 blt- cr4,ffc20d48 <rtems_rfs_bitmap_map_alloc+0x48><== NOT EXECUTED
lower_seed -= window;
ffc20da4: 3b de f8 00 addi r30,r30,-2048 <== NOT EXECUTED
* we have searched all of the map. The seed may not be aligned to a window
* boundary so we may need to search a partial window and this may also not
* be balanced for the upper or lower seeds. We move to the limits, search
* then return false if no clear bits are found.
*/
while (((upper_seed >= 0) && (upper_seed < control->size))
ffc20da8: 40 8c ff a4 bge+ cr3,ffc20d4c <rtems_rfs_bitmap_map_alloc+0x4c><== NOT EXECUTED
|| ((lower_seed >= 0) && (lower_seed < control->size)))
ffc20dac: 2e 1e 00 00 cmpwi cr4,r30,0 <== NOT EXECUTED
ffc20db0: 41 90 00 44 blt- cr4,ffc20df4 <rtems_rfs_bitmap_map_alloc+0xf4><== NOT EXECUTED
ffc20db4: 80 1d 00 0c lwz r0,12(r29) <== NOT EXECUTED
ffc20db8: 7f 9e 00 40 cmplw cr7,r30,r0 <== NOT EXECUTED
ffc20dbc: 40 9c 00 38 bge- cr7,ffc20df4 <rtems_rfs_bitmap_map_alloc+0xf4><== NOT EXECUTED
{
/*
* Search up first so bits allocated in succession are grouped together.
*/
if (upper_seed < control->size)
ffc20dc0: 7f 80 f8 40 cmplw cr7,r0,r31 <== NOT EXECUTED
ffc20dc4: 41 bd ff 94 bgt- cr7,ffc20d58 <rtems_rfs_bitmap_map_alloc+0x58><== NOT EXECUTED
break;
}
if (lower_seed >= 0)
{
*bit = lower_seed;
ffc20dc8: 93 db 00 00 stw r30,0(r27) <== NOT EXECUTED
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
ffc20dcc: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc20dd0: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc20dd4: 7f 85 e3 78 mr r5,r28 <== NOT EXECUTED
ffc20dd8: 38 c0 ff ff li r6,-1 <== NOT EXECUTED
ffc20ddc: 4b ff f8 5d bl ffc20638 <rtems_rfs_search_map_for_clear_bit.constprop.1><== NOT EXECUTED
window, -1);
if ((rc > 0) || *allocated)
ffc20de0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc20de4: 41 9d 00 10 bgt- cr7,ffc20df4 <rtems_rfs_bitmap_map_alloc+0xf4><== NOT EXECUTED
ffc20de8: 88 1c 00 00 lbz r0,0(r28) <== NOT EXECUTED
ffc20dec: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc20df0: 41 9e ff 9c beq+ cr7,ffc20d8c <rtems_rfs_bitmap_map_alloc+0x8c><== NOT EXECUTED
if (lower_seed >= 0)
lower_seed -= window;
}
return 0;
}
ffc20df4: 80 01 00 24 lwz r0,36(r1)
ffc20df8: 38 60 00 00 li r3,0
ffc20dfc: 81 81 00 08 lwz r12,8(r1)
ffc20e00: 7c 08 03 a6 mtlr r0
ffc20e04: 83 61 00 0c lwz r27,12(r1)
ffc20e08: 83 81 00 10 lwz r28,16(r1)
ffc20e0c: 7d 81 81 20 mtcrf 24,r12
ffc20e10: 83 a1 00 14 lwz r29,20(r1)
ffc20e14: 83 c1 00 18 lwz r30,24(r1)
ffc20e18: 83 e1 00 1c lwz r31,28(r1)
ffc20e1c: 38 21 00 20 addi r1,r1,32
ffc20e20: 4e 80 00 20 blr
ffc209e4 <rtems_rfs_bitmap_map_clear>:
}
int
rtems_rfs_bitmap_map_clear (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
ffc209e4: 94 21 ff e0 stwu r1,-32(r1)
ffc209e8: 7c 08 02 a6 mflr r0
ffc209ec: 93 c1 00 18 stw r30,24(r1)
ffc209f0: 7c 9e 23 78 mr r30,r4
rtems_rfs_bitmap_map map;
rtems_rfs_bitmap_map search_map;
int index;
int offset;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
ffc209f4: 38 81 00 08 addi r4,r1,8
}
int
rtems_rfs_bitmap_map_clear (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
ffc209f8: 93 e1 00 1c stw r31,28(r1)
ffc209fc: 7c 7f 1b 78 mr r31,r3
ffc20a00: 90 01 00 24 stw r0,36(r1)
rtems_rfs_bitmap_map map;
rtems_rfs_bitmap_map search_map;
int index;
int offset;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
ffc20a04: 4b ff fb bd bl ffc205c0 <rtems_rfs_bitmap_load_map>
if (rc > 0)
ffc20a08: 2c 03 00 00 cmpwi r3,0
ffc20a0c: 40 81 00 1c ble- ffc20a28 <rtems_rfs_bitmap_map_clear+0x44><== ALWAYS TAKEN
offset = rtems_rfs_bitmap_map_offset(bit);
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
rtems_rfs_buffer_mark_dirty (control->buffer);
control->free++;
return 0;
}
ffc20a10: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
ffc20a14: 83 c1 00 18 lwz r30,24(r1) <== NOT EXECUTED
ffc20a18: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc20a1c: 83 e1 00 1c lwz r31,28(r1) <== NOT EXECUTED
ffc20a20: 38 21 00 20 addi r1,r1,32 <== NOT EXECUTED
ffc20a24: 4e 80 00 20 blr <== NOT EXECUTED
int offset;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
ffc20a28: 80 1f 00 0c lwz r0,12(r31)
return EINVAL;
ffc20a2c: 38 60 00 16 li r3,22
int offset;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
ffc20a30: 7f 9e 00 40 cmplw cr7,r30,r0
ffc20a34: 40 9c ff dc bge+ cr7,ffc20a10 <rtems_rfs_bitmap_map_clear+0x2c><== NEVER TAKEN
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset);
ffc20a38: 81 01 00 08 lwz r8,8(r1)
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
ffc20a3c: 7f cb 2e 70 srawi r11,r30,5
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset);
ffc20a40: 55 6a 10 3a rlwinm r10,r11,2,0,29
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_clear (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits);
ffc20a44: 7d 28 50 2e lwzx r9,r8,r10
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset);
ffc20a48: 38 00 00 01 li r0,1
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
ffc20a4c: 57 c7 06 fe clrlwi r7,r30,27
map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset);
ffc20a50: 7c 07 38 30 slw r7,r0,r7
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_clear (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits);
ffc20a54: 7d 27 3b 78 or r7,r9,r7
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
ffc20a58: 81 3f 00 14 lwz r9,20(r31)
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset);
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
ffc20a5c: 7f de 56 70 srawi r30,r30,10
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset);
ffc20a60: 7c e8 51 2e stwx r7,r8,r10
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset(bit);
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
ffc20a64: 57 de 10 3a rlwinm r30,r30,2,0,29
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_clear (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits);
ffc20a68: 7c e9 f0 2e lwzx r7,r9,r30
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset);
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset(bit);
ffc20a6c: 55 6b 06 fe clrlwi r11,r11,27
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
rtems_rfs_buffer_mark_dirty (control->buffer);
ffc20a70: 81 1f 00 00 lwz r8,0(r31)
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset);
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset(bit);
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
ffc20a74: 7c 0b 58 30 slw r11,r0,r11
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_clear (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits);
ffc20a78: 7c eb 5b 78 or r11,r7,r11
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset(bit);
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
rtems_rfs_buffer_mark_dirty (control->buffer);
control->free++;
ffc20a7c: 81 5f 00 10 lwz r10,16(r31)
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset);
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset(bit);
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
ffc20a80: 7d 69 f1 2e stwx r11,r9,r30
rtems_rfs_buffer_mark_dirty (control->buffer);
control->free++;
return 0;
ffc20a84: 38 60 00 00 li r3,0
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset(bit);
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
rtems_rfs_buffer_mark_dirty (control->buffer);
control->free++;
ffc20a88: 39 4a 00 01 addi r10,r10,1
map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset);
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset(bit);
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
rtems_rfs_buffer_mark_dirty (control->buffer);
ffc20a8c: 98 08 00 00 stb r0,0(r8)
control->free++;
return 0;
}
ffc20a90: 80 01 00 24 lwz r0,36(r1)
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset(bit);
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
rtems_rfs_buffer_mark_dirty (control->buffer);
control->free++;
ffc20a94: 91 5f 00 10 stw r10,16(r31)
return 0;
}
ffc20a98: 7c 08 03 a6 mtlr r0
ffc20a9c: 83 c1 00 18 lwz r30,24(r1)
ffc20aa0: 83 e1 00 1c lwz r31,28(r1)
ffc20aa4: 38 21 00 20 addi r1,r1,32
ffc20aa8: 4e 80 00 20 blr
ffc20c1c <rtems_rfs_bitmap_map_clear_all>:
int
rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control)
{
ffc20c1c: 94 21 ff e0 stwu r1,-32(r1)
ffc20c20: 7c 08 02 a6 mflr r0
rtems_rfs_bitmap_bit last_search_bit;
size_t elements;
int e;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
ffc20c24: 38 81 00 08 addi r4,r1,8
return 0;
}
int
rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control)
{
ffc20c28: 93 e1 00 1c stw r31,28(r1)
ffc20c2c: 7c 7f 1b 78 mr r31,r3
ffc20c30: 90 01 00 24 stw r0,36(r1)
rtems_rfs_bitmap_bit last_search_bit;
size_t elements;
int e;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
ffc20c34: 4b ff f9 8d bl ffc205c0 <rtems_rfs_bitmap_load_map>
if (rc > 0)
ffc20c38: 2c 03 00 00 cmpwi r3,0
ffc20c3c: 40 81 00 18 ble- ffc20c54 <rtems_rfs_bitmap_map_clear_all+0x38><== ALWAYS TAKEN
rtems_rfs_bitmap_mask (last_search_bit));
rtems_rfs_buffer_mark_dirty (control->buffer);
return 0;
}
ffc20c40: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
ffc20c44: 83 e1 00 1c lwz r31,28(r1) <== NOT EXECUTED
ffc20c48: 38 21 00 20 addi r1,r1,32 <== NOT EXECUTED
ffc20c4c: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc20c50: 4e 80 00 20 blr <== NOT EXECUTED
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
ffc20c54: 80 ff 00 0c lwz r7,12(r31)
control->free = elements;
for (e = 0; e < elements; e++)
ffc20c58: 38 00 00 00 li r0,0
if (rc > 0)
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
control->free = elements;
ffc20c5c: 81 41 00 08 lwz r10,8(r1)
for (e = 0; e < elements; e++)
ffc20c60: 39 20 00 00 li r9,0
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
ffc20c64: 38 e7 ff ff addi r7,r7,-1
ffc20c68: 54 e7 d9 7e rlwinm r7,r7,27,5,31
ffc20c6c: 39 07 00 01 addi r8,r7,1
control->free = elements;
for (e = 0; e < elements; e++)
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
ffc20c70: 7d 09 03 a6 mtctr r8
if (rc > 0)
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
control->free = elements;
ffc20c74: 91 1f 00 10 stw r8,16(r31)
for (e = 0; e < elements; e++)
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
ffc20c78: 39 60 ff ff li r11,-1
ffc20c7c: 54 00 10 3a rlwinm r0,r0,2,0,29
elements = rtems_rfs_bitmap_elements (control->size);
control->free = elements;
for (e = 0; e < elements; e++)
ffc20c80: 39 29 00 01 addi r9,r9,1
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
ffc20c84: 7d 6a 01 2e stwx r11,r10,r0
elements = rtems_rfs_bitmap_elements (control->size);
control->free = elements;
for (e = 0; e < elements; e++)
ffc20c88: 7d 20 4b 78 mr r0,r9
ffc20c8c: 42 00 ff f0 bdnz+ ffc20c7c <rtems_rfs_bitmap_map_clear_all+0x60>
* Set the un-mapped bits in the last search element so the available logic
* works.
*/
last_search_bit = rtems_rfs_bitmap_map_offset (elements);
if (last_search_bit == 0)
ffc20c90: 71 08 00 1f andi. r8,r8,31
ffc20c94: 38 c0 ff ff li r6,-1
ffc20c98: 41 82 00 0c beq- ffc20ca4 <rtems_rfs_bitmap_map_clear_all+0x88><== ALWAYS TAKEN
ffc20c9c: 21 08 00 20 subfic r8,r8,32 <== NOT EXECUTED
ffc20ca0: 7c c6 44 30 srw r6,r6,r8 <== NOT EXECUTED
last_search_bit = rtems_rfs_bitmap_element_bits ();
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < (elements - 1); e++)
ffc20ca4: 54 e7 d9 7f rlwinm. r7,r7,27,5,31
ffc20ca8: 81 7f 00 14 lwz r11,20(r31)
ffc20cac: 41 82 00 28 beq- ffc20cd4 <rtems_rfs_bitmap_map_clear_all+0xb8><== ALWAYS TAKEN
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
ffc20cb0: 7c e9 03 a6 mtctr r7 <== NOT EXECUTED
if (last_search_bit == 0)
last_search_bit = rtems_rfs_bitmap_element_bits ();
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < (elements - 1); e++)
ffc20cb4: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc20cb8: 39 20 00 00 li r9,0 <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
ffc20cbc: 39 40 ff ff li r10,-1 <== NOT EXECUTED
ffc20cc0: 54 00 10 3a rlwinm r0,r0,2,0,29 <== NOT EXECUTED
if (last_search_bit == 0)
last_search_bit = rtems_rfs_bitmap_element_bits ();
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < (elements - 1); e++)
ffc20cc4: 39 29 00 01 addi r9,r9,1 <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
ffc20cc8: 7d 4b 01 2e stwx r10,r11,r0 <== NOT EXECUTED
if (last_search_bit == 0)
last_search_bit = rtems_rfs_bitmap_element_bits ();
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < (elements - 1); e++)
ffc20ccc: 7d 20 4b 78 mr r0,r9 <== NOT EXECUTED
ffc20cd0: 42 00 ff f0 bdnz+ ffc20cc0 <rtems_rfs_bitmap_map_clear_all+0xa4><== NOT EXECUTED
control->search_bits[elements - 1] =
rtems_rfs_bitmap_merge (RTEMS_RFS_BITMAP_ELEMENT_CLEAR,
RTEMS_RFS_BITMAP_ELEMENT_SET,
rtems_rfs_bitmap_mask (last_search_bit));
rtems_rfs_buffer_mark_dirty (control->buffer);
ffc20cd4: 81 3f 00 00 lwz r9,0(r31)
ffc20cd8: 38 00 00 01 li r0,1
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < (elements - 1); e++)
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
control->search_bits[elements - 1] =
ffc20cdc: 54 e7 10 3a rlwinm r7,r7,2,0,29
rtems_rfs_bitmap_mask (last_search_bit));
rtems_rfs_buffer_mark_dirty (control->buffer);
return 0;
}
ffc20ce0: 83 e1 00 1c lwz r31,28(r1)
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < (elements - 1); e++)
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
control->search_bits[elements - 1] =
ffc20ce4: 7c cb 39 2e stwx r6,r11,r7
RTEMS_RFS_BITMAP_ELEMENT_SET,
rtems_rfs_bitmap_mask (last_search_bit));
rtems_rfs_buffer_mark_dirty (control->buffer);
return 0;
ffc20ce8: 38 60 00 00 li r3,0
control->search_bits[elements - 1] =
rtems_rfs_bitmap_merge (RTEMS_RFS_BITMAP_ELEMENT_CLEAR,
RTEMS_RFS_BITMAP_ELEMENT_SET,
rtems_rfs_bitmap_mask (last_search_bit));
rtems_rfs_buffer_mark_dirty (control->buffer);
ffc20cec: 98 09 00 00 stb r0,0(r9)
return 0;
}
ffc20cf0: 80 01 00 24 lwz r0,36(r1)
ffc20cf4: 38 21 00 20 addi r1,r1,32
ffc20cf8: 7c 08 03 a6 mtlr r0
ffc20cfc: 4e 80 00 20 blr
ffc20928 <rtems_rfs_bitmap_map_set>:
int
rtems_rfs_bitmap_map_set (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
ffc20928: 94 21 ff e0 stwu r1,-32(r1)
ffc2092c: 7c 08 02 a6 mflr r0
ffc20930: 93 c1 00 18 stw r30,24(r1)
ffc20934: 7c 9e 23 78 mr r30,r4
rtems_rfs_bitmap_map map;
rtems_rfs_bitmap_map search_map;
int index;
int offset;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
ffc20938: 38 81 00 08 addi r4,r1,8
}
int
rtems_rfs_bitmap_map_set (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
ffc2093c: 93 e1 00 1c stw r31,28(r1)
ffc20940: 7c 7f 1b 78 mr r31,r3
ffc20944: 90 01 00 24 stw r0,36(r1)
rtems_rfs_bitmap_map map;
rtems_rfs_bitmap_map search_map;
int index;
int offset;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
ffc20948: 4b ff fc 79 bl ffc205c0 <rtems_rfs_bitmap_load_map>
if (rc > 0)
ffc2094c: 2c 03 00 00 cmpwi r3,0
ffc20950: 40 81 00 1c ble- ffc2096c <rtems_rfs_bitmap_map_set+0x44><== ALWAYS TAKEN
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
control->free--;
rtems_rfs_buffer_mark_dirty (control->buffer);
}
return 0;
}
ffc20954: 80 01 00 24 lwz r0,36(r1)
ffc20958: 83 c1 00 18 lwz r30,24(r1)
ffc2095c: 7c 08 03 a6 mtlr r0
ffc20960: 83 e1 00 1c lwz r31,28(r1)
ffc20964: 38 21 00 20 addi r1,r1,32
ffc20968: 4e 80 00 20 blr
int offset;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
ffc2096c: 80 1f 00 0c lwz r0,12(r31)
return EINVAL;
ffc20970: 38 60 00 16 li r3,22
int offset;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
ffc20974: 7f 9e 00 40 cmplw cr7,r30,r0
ffc20978: 40 9c ff dc bge+ cr7,ffc20954 <rtems_rfs_bitmap_map_set+0x2c><== NEVER TAKEN
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);
ffc2097c: 81 61 00 08 lwz r11,8(r1)
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
ffc20980: 7f c8 2e 70 srawi r8,r30,5
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);
ffc20984: 55 09 10 3a rlwinm r9,r8,2,0,29
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
ffc20988: 7c eb 48 2e lwzx r7,r11,r9
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
ffc2098c: 57 ca 06 fe clrlwi r10,r30,27
map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);
ffc20990: 38 00 00 01 li r0,1
ffc20994: 7c 0a 50 30 slw r10,r0,r10
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
ffc20998: 7c ea 50 78 andc r10,r7,r10
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
ffc2099c: 80 ff 00 14 lwz r7,20(r31)
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);
if (rtems_rfs_bitmap_match(map[index], RTEMS_RFS_BITMAP_ELEMENT_SET))
ffc209a0: 2f 8a 00 00 cmpwi cr7,r10,0
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);
ffc209a4: 7d 4b 49 2e stwx r10,r11,r9
offset = rtems_rfs_bitmap_map_offset (bit);
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
control->free--;
rtems_rfs_buffer_mark_dirty (control->buffer);
}
return 0;
ffc209a8: 38 60 00 00 li r3,0
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);
if (rtems_rfs_bitmap_match(map[index], RTEMS_RFS_BITMAP_ELEMENT_SET))
ffc209ac: 40 be ff a8 bne- cr7,ffc20954 <rtems_rfs_bitmap_map_set+0x2c><== ALWAYS TAKEN
{
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
ffc209b0: 7f de 56 70 srawi r30,r30,10 <== NOT EXECUTED
offset = rtems_rfs_bitmap_map_offset (bit);
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
control->free--;
ffc209b4: 81 7f 00 10 lwz r11,16(r31) <== NOT EXECUTED
if (rtems_rfs_bitmap_match(map[index], RTEMS_RFS_BITMAP_ELEMENT_SET))
{
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
ffc209b8: 57 de 10 3a rlwinm r30,r30,2,0,29 <== NOT EXECUTED
control->free--;
rtems_rfs_buffer_mark_dirty (control->buffer);
ffc209bc: 81 3f 00 00 lwz r9,0(r31) <== NOT EXECUTED
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
ffc209c0: 7d 47 f0 2e lwzx r10,r7,r30 <== NOT EXECUTED
map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);
if (rtems_rfs_bitmap_match(map[index], RTEMS_RFS_BITMAP_ELEMENT_SET))
{
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
ffc209c4: 55 08 06 fe clrlwi r8,r8,27 <== NOT EXECUTED
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
ffc209c8: 7c 08 40 30 slw r8,r0,r8 <== NOT EXECUTED
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
ffc209cc: 7d 48 40 78 andc r8,r10,r8 <== NOT EXECUTED
{
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
control->free--;
ffc209d0: 39 6b ff ff addi r11,r11,-1 <== NOT EXECUTED
if (rtems_rfs_bitmap_match(map[index], RTEMS_RFS_BITMAP_ELEMENT_SET))
{
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
ffc209d4: 7d 07 f1 2e stwx r8,r7,r30 <== NOT EXECUTED
control->free--;
ffc209d8: 91 7f 00 10 stw r11,16(r31) <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (control->buffer);
ffc209dc: 98 09 00 00 stb r0,0(r9) <== NOT EXECUTED
ffc209e0: 4b ff ff 74 b ffc20954 <rtems_rfs_bitmap_map_set+0x2c><== NOT EXECUTED
ffc20b54 <rtems_rfs_bitmap_map_set_all>:
int
rtems_rfs_bitmap_map_set_all (rtems_rfs_bitmap_control* control)
{
ffc20b54: 94 21 ff e0 stwu r1,-32(r1) <== NOT EXECUTED
ffc20b58: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
rtems_rfs_bitmap_map map;
size_t elements;
int e;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
ffc20b5c: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
return 0;
}
int
rtems_rfs_bitmap_map_set_all (rtems_rfs_bitmap_control* control)
{
ffc20b60: 93 e1 00 1c stw r31,28(r1) <== NOT EXECUTED
ffc20b64: 7c 7f 1b 78 mr r31,r3 <== NOT EXECUTED
ffc20b68: 90 01 00 24 stw r0,36(r1) <== NOT EXECUTED
rtems_rfs_bitmap_map map;
size_t elements;
int e;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
ffc20b6c: 4b ff fa 55 bl ffc205c0 <rtems_rfs_bitmap_load_map> <== NOT EXECUTED
if (rc > 0)
ffc20b70: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc20b74: 40 81 00 18 ble- ffc20b8c <rtems_rfs_bitmap_map_set_all+0x38><== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
rtems_rfs_buffer_mark_dirty (control->buffer);
return 0;
}
ffc20b78: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
ffc20b7c: 83 e1 00 1c lwz r31,28(r1) <== NOT EXECUTED
ffc20b80: 38 21 00 20 addi r1,r1,32 <== NOT EXECUTED
ffc20b84: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc20b88: 4e 80 00 20 blr <== NOT EXECUTED
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
ffc20b8c: 81 1f 00 0c lwz r8,12(r31) <== NOT EXECUTED
control->free = 0;
ffc20b90: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc20b94: 90 1f 00 10 stw r0,16(r31) <== NOT EXECUTED
for (e = 0; e < elements; e++)
ffc20b98: 39 20 00 00 li r9,0 <== NOT EXECUTED
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
ffc20b9c: 39 08 ff ff addi r8,r8,-1 <== NOT EXECUTED
ffc20ba0: 55 08 d9 7e rlwinm r8,r8,27,5,31 <== NOT EXECUTED
control->free = 0;
ffc20ba4: 81 41 00 08 lwz r10,8(r1) <== NOT EXECUTED
for (e = 0; e < elements; e++)
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
ffc20ba8: 38 e8 00 01 addi r7,r8,1 <== NOT EXECUTED
ffc20bac: 7c e9 03 a6 mtctr r7 <== NOT EXECUTED
ffc20bb0: 39 60 00 00 li r11,0 <== NOT EXECUTED
ffc20bb4: 54 00 10 3a rlwinm r0,r0,2,0,29 <== NOT EXECUTED
elements = rtems_rfs_bitmap_elements (control->size);
control->free = 0;
for (e = 0; e < elements; e++)
ffc20bb8: 39 29 00 01 addi r9,r9,1 <== NOT EXECUTED
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
ffc20bbc: 7d 6a 01 2e stwx r11,r10,r0 <== NOT EXECUTED
elements = rtems_rfs_bitmap_elements (control->size);
control->free = 0;
for (e = 0; e < elements; e++)
ffc20bc0: 7d 20 4b 78 mr r0,r9 <== NOT EXECUTED
ffc20bc4: 42 00 ff f0 bdnz+ ffc20bb4 <rtems_rfs_bitmap_map_set_all+0x60><== NOT EXECUTED
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
elements = rtems_rfs_bitmap_elements (elements);
ffc20bc8: 55 08 d9 7e rlwinm r8,r8,27,5,31 <== NOT EXECUTED
ffc20bcc: 81 5f 00 14 lwz r10,20(r31) <== NOT EXECUTED
for (e = 0; e < elements; e++)
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
ffc20bd0: 39 08 00 01 addi r8,r8,1 <== NOT EXECUTED
ffc20bd4: 7d 09 03 a6 mtctr r8 <== NOT EXECUTED
for (e = 0; e < elements; e++)
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < elements; e++)
ffc20bd8: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc20bdc: 39 20 00 00 li r9,0 <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
ffc20be0: 39 60 00 00 li r11,0 <== NOT EXECUTED
ffc20be4: 54 00 10 3a rlwinm r0,r0,2,0,29 <== NOT EXECUTED
for (e = 0; e < elements; e++)
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < elements; e++)
ffc20be8: 39 29 00 01 addi r9,r9,1 <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
ffc20bec: 7d 6a 01 2e stwx r11,r10,r0 <== NOT EXECUTED
for (e = 0; e < elements; e++)
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < elements; e++)
ffc20bf0: 7d 20 4b 78 mr r0,r9 <== NOT EXECUTED
ffc20bf4: 42 00 ff f0 bdnz+ ffc20be4 <rtems_rfs_bitmap_map_set_all+0x90><== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
rtems_rfs_buffer_mark_dirty (control->buffer);
ffc20bf8: 81 3f 00 00 lwz r9,0(r31) <== NOT EXECUTED
ffc20bfc: 38 00 00 01 li r0,1 <== NOT EXECUTED
return 0;
ffc20c00: 38 60 00 00 li r3,0 <== NOT EXECUTED
}
ffc20c04: 83 e1 00 1c lwz r31,28(r1) <== NOT EXECUTED
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < elements; e++)
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
rtems_rfs_buffer_mark_dirty (control->buffer);
ffc20c08: 98 09 00 00 stb r0,0(r9) <== NOT EXECUTED
return 0;
}
ffc20c0c: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
ffc20c10: 38 21 00 20 addi r1,r1,32 <== NOT EXECUTED
ffc20c14: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc20c18: 4e 80 00 20 blr <== NOT EXECUTED
ffc20aac <rtems_rfs_bitmap_map_test>:
int
rtems_rfs_bitmap_map_test (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit,
bool* state)
{
ffc20aac: 94 21 ff d8 stwu r1,-40(r1) <== NOT EXECUTED
ffc20ab0: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc20ab4: 93 e1 00 24 stw r31,36(r1) <== NOT EXECUTED
ffc20ab8: 7c 9f 23 78 mr r31,r4 <== NOT EXECUTED
rtems_rfs_bitmap_map map;
int index;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
ffc20abc: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
int
rtems_rfs_bitmap_map_test (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit,
bool* state)
{
ffc20ac0: 93 a1 00 1c stw r29,28(r1) <== NOT EXECUTED
ffc20ac4: 7c bd 2b 78 mr r29,r5 <== NOT EXECUTED
ffc20ac8: 93 c1 00 20 stw r30,32(r1) <== NOT EXECUTED
ffc20acc: 7c 7e 1b 78 mr r30,r3 <== NOT EXECUTED
ffc20ad0: 90 01 00 2c stw r0,44(r1) <== NOT EXECUTED
rtems_rfs_bitmap_map map;
int index;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
ffc20ad4: 4b ff fa ed bl ffc205c0 <rtems_rfs_bitmap_load_map> <== NOT EXECUTED
if (rc > 0)
ffc20ad8: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc20adc: 40 81 00 20 ble- ffc20afc <rtems_rfs_bitmap_map_test+0x50><== NOT EXECUTED
if (bit >= control->size)
return EINVAL;
index = rtems_rfs_bitmap_map_index (bit);
*state = rtems_rfs_bitmap_test (map[index], bit);
return 0;
}
ffc20ae0: 80 01 00 2c lwz r0,44(r1) <== NOT EXECUTED
ffc20ae4: 83 a1 00 1c lwz r29,28(r1) <== NOT EXECUTED
ffc20ae8: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc20aec: 83 c1 00 20 lwz r30,32(r1) <== NOT EXECUTED
ffc20af0: 83 e1 00 24 lwz r31,36(r1) <== NOT EXECUTED
ffc20af4: 38 21 00 28 addi r1,r1,40 <== NOT EXECUTED
ffc20af8: 4e 80 00 20 blr <== NOT EXECUTED
int index;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
ffc20afc: 80 1e 00 0c lwz r0,12(r30) <== NOT EXECUTED
return EINVAL;
ffc20b00: 38 60 00 16 li r3,22 <== NOT EXECUTED
int index;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
ffc20b04: 7f 9f 00 40 cmplw cr7,r31,r0 <== NOT EXECUTED
ffc20b08: 40 9c ff d8 bge+ cr7,ffc20ae0 <rtems_rfs_bitmap_map_test+0x34><== NOT EXECUTED
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
ffc20b0c: 81 21 00 08 lwz r9,8(r1) <== NOT EXECUTED
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
index = rtems_rfs_bitmap_map_index (bit);
ffc20b10: 7f e0 2e 70 srawi r0,r31,5 <== NOT EXECUTED
*state = rtems_rfs_bitmap_test (map[index], bit);
ffc20b14: 54 00 10 3a rlwinm r0,r0,2,0,29 <== NOT EXECUTED
return 0;
}
ffc20b18: 83 c1 00 20 lwz r30,32(r1) <== NOT EXECUTED
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
ffc20b1c: 7c 09 00 2e lwzx r0,r9,r0 <== NOT EXECUTED
ffc20b20: 39 20 00 01 li r9,1 <== NOT EXECUTED
ffc20b24: 7d 3f f8 30 slw r31,r9,r31 <== NOT EXECUTED
ffc20b28: 7f e9 00 39 and. r9,r31,r0 <== NOT EXECUTED
if (bit >= control->size)
return EINVAL;
index = rtems_rfs_bitmap_map_index (bit);
*state = rtems_rfs_bitmap_test (map[index], bit);
return 0;
}
ffc20b2c: 83 e1 00 24 lwz r31,36(r1) <== NOT EXECUTED
return rc;
if (bit >= control->size)
return EINVAL;
index = rtems_rfs_bitmap_map_index (bit);
*state = rtems_rfs_bitmap_test (map[index], bit);
return 0;
ffc20b30: 38 60 00 00 li r3,0 <== NOT EXECUTED
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
ffc20b34: 7c 00 00 26 mfcr r0 <== NOT EXECUTED
ffc20b38: 54 00 1f fe rlwinm r0,r0,3,31,31 <== NOT EXECUTED
ffc20b3c: 98 1d 00 00 stb r0,0(r29) <== NOT EXECUTED
if (bit >= control->size)
return EINVAL;
index = rtems_rfs_bitmap_map_index (bit);
*state = rtems_rfs_bitmap_test (map[index], bit);
return 0;
}
ffc20b40: 80 01 00 2c lwz r0,44(r1) <== NOT EXECUTED
ffc20b44: 83 a1 00 1c lwz r29,28(r1) <== NOT EXECUTED
ffc20b48: 38 21 00 28 addi r1,r1,40 <== NOT EXECUTED
ffc20b4c: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc20b50: 4e 80 00 20 blr <== NOT EXECUTED
ffc208f0 <rtems_rfs_bitmap_mask>:
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask (unsigned int size)
{
rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK;
mask >>= (rtems_rfs_bitmap_element_bits () - size);
ffc208f0: 38 00 ff ff li r0,-1 <== NOT EXECUTED
ffc208f4: 20 63 00 20 subfic r3,r3,32 <== NOT EXECUTED
return mask;
}
ffc208f8: 7c 03 1c 30 srw r3,r0,r3 <== NOT EXECUTED
ffc208fc: 4e 80 00 20 blr <== NOT EXECUTED
ffc20900 <rtems_rfs_bitmap_mask_section>:
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end)
{
rtems_rfs_bitmap_element mask = 0;
if (end > start)
ffc20900: 7f 84 18 40 cmplw cr7,r4,r3 <== NOT EXECUTED
return mask;
}
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end)
{
ffc20904: 7c 60 1b 78 mr r0,r3 <== NOT EXECUTED
rtems_rfs_bitmap_element mask = 0;
ffc20908: 38 60 00 00 li r3,0 <== NOT EXECUTED
if (end > start)
ffc2090c: 4c 9d 00 20 blelr cr7 <== NOT EXECUTED
mask = rtems_rfs_bitmap_mask (end - start) << start;
ffc20910: 7c 80 20 50 subf r4,r0,r4 <== NOT EXECUTED
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask (unsigned int size)
{
rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK;
mask >>= (rtems_rfs_bitmap_element_bits () - size);
ffc20914: 20 84 00 20 subfic r4,r4,32 <== NOT EXECUTED
ffc20918: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc2091c: 7c 63 24 30 srw r3,r3,r4 <== NOT EXECUTED
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end)
{
rtems_rfs_bitmap_element mask = 0;
if (end > start)
mask = rtems_rfs_bitmap_mask (end - start) << start;
ffc20920: 7c 63 00 30 slw r3,r3,r0 <== NOT EXECUTED
return mask;
}
ffc20924: 4e 80 00 20 blr <== NOT EXECUTED
ffc20f48 <rtems_rfs_bitmap_open>:
rtems_rfs_bitmap_open (rtems_rfs_bitmap_control* control,
rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* buffer,
size_t size,
rtems_rfs_buffer_block block)
{
ffc20f48: 94 21 ff f0 stwu r1,-16(r1)
ffc20f4c: 7c 08 02 a6 mflr r0
ffc20f50: 93 e1 00 0c stw r31,12(r1)
ffc20f54: 7c 7f 1b 78 mr r31,r3
size_t elements = rtems_rfs_bitmap_elements (size);
ffc20f58: 38 66 ff ff addi r3,r6,-1
rtems_rfs_bitmap_open (rtems_rfs_bitmap_control* control,
rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* buffer,
size_t size,
rtems_rfs_buffer_block block)
{
ffc20f5c: 90 01 00 14 stw r0,20(r1)
control->buffer = buffer;
control->fs = fs;
control->block = block;
control->size = size;
elements = rtems_rfs_bitmap_elements (elements);
ffc20f60: 54 63 c2 3a rlwinm r3,r3,24,8,29
control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
ffc20f64: 38 63 00 04 addi r3,r3,4
size_t size,
rtems_rfs_buffer_block block)
{
size_t elements = rtems_rfs_bitmap_elements (size);
control->buffer = buffer;
ffc20f68: 90 bf 00 00 stw r5,0(r31)
control->fs = fs;
ffc20f6c: 90 9f 00 04 stw r4,4(r31)
control->block = block;
ffc20f70: 90 ff 00 08 stw r7,8(r31)
control->size = size;
ffc20f74: 90 df 00 0c stw r6,12(r31)
elements = rtems_rfs_bitmap_elements (elements);
control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
ffc20f78: 4b fe 7e 75 bl ffc08dec <malloc>
if (!control->search_bits)
ffc20f7c: 2f 83 00 00 cmpwi cr7,r3,0
control->fs = fs;
control->block = block;
control->size = size;
elements = rtems_rfs_bitmap_elements (elements);
control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
ffc20f80: 90 7f 00 14 stw r3,20(r31)
if (!control->search_bits)
ffc20f84: 41 9e 00 1c beq- cr7,ffc20fa0 <rtems_rfs_bitmap_open+0x58><== NEVER TAKEN
return ENOMEM;
return rtems_rfs_bitmap_create_search (control);
}
ffc20f88: 80 01 00 14 lwz r0,20(r1)
control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
if (!control->search_bits)
return ENOMEM;
return rtems_rfs_bitmap_create_search (control);
ffc20f8c: 7f e3 fb 78 mr r3,r31
}
ffc20f90: 83 e1 00 0c lwz r31,12(r1)
ffc20f94: 38 21 00 10 addi r1,r1,16
ffc20f98: 7c 08 03 a6 mtlr r0
control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
if (!control->search_bits)
return ENOMEM;
return rtems_rfs_bitmap_create_search (control);
ffc20f9c: 4b ff fe 88 b ffc20e24 <rtems_rfs_bitmap_create_search>
}
ffc20fa0: 80 01 00 14 lwz r0,20(r1) <== NOT EXECUTED
ffc20fa4: 38 60 00 0c li r3,12 <== NOT EXECUTED
ffc20fa8: 83 e1 00 0c lwz r31,12(r1) <== NOT EXECUTED
ffc20fac: 38 21 00 10 addi r1,r1,16 <== NOT EXECUTED
ffc20fb0: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc20fb4: 4e 80 00 20 blr <== NOT EXECUTED
ffc211a8 <rtems_rfs_block_find_indirect>:
rtems_rfs_block_find_indirect (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no block,
int offset,
rtems_rfs_block_no* result)
{
ffc211a8: 94 21 ff e0 stwu r1,-32(r1) <== NOT EXECUTED
ffc211ac: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc211b0: 93 e1 00 1c stw r31,28(r1) <== NOT EXECUTED
ffc211b4: 7c df 33 78 mr r31,r6 <== NOT EXECUTED
/*
* If the handle has a buffer and this request is a different block the current
* buffer is released.
*/
rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);
ffc211b8: 38 c0 00 01 li r6,1 <== NOT EXECUTED
rtems_rfs_block_find_indirect (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no block,
int offset,
rtems_rfs_block_no* result)
{
ffc211bc: 93 61 00 0c stw r27,12(r1) <== NOT EXECUTED
ffc211c0: 7c fb 3b 78 mr r27,r7 <== NOT EXECUTED
ffc211c4: 93 81 00 10 stw r28,16(r1) <== NOT EXECUTED
ffc211c8: 7c bc 2b 78 mr r28,r5 <== NOT EXECUTED
ffc211cc: 93 a1 00 14 stw r29,20(r1) <== NOT EXECUTED
ffc211d0: 7c 9d 23 78 mr r29,r4 <== NOT EXECUTED
ffc211d4: 93 c1 00 18 stw r30,24(r1) <== NOT EXECUTED
ffc211d8: 7c 7e 1b 78 mr r30,r3 <== NOT EXECUTED
ffc211dc: 90 01 00 24 stw r0,36(r1) <== NOT EXECUTED
/*
* If the handle has a buffer and this request is a different block the current
* buffer is released.
*/
rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);
ffc211e0: 48 00 16 75 bl ffc22854 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
if (rc > 0)
ffc211e4: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc211e8: 40 81 00 28 ble- ffc21210 <rtems_rfs_block_find_indirect+0x68><== NOT EXECUTED
*result = 0;
rc = EIO;
}
return 0;
}
ffc211ec: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
ffc211f0: 83 61 00 0c lwz r27,12(r1) <== NOT EXECUTED
ffc211f4: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc211f8: 83 81 00 10 lwz r28,16(r1) <== NOT EXECUTED
ffc211fc: 83 a1 00 14 lwz r29,20(r1) <== NOT EXECUTED
ffc21200: 83 c1 00 18 lwz r30,24(r1) <== NOT EXECUTED
ffc21204: 83 e1 00 1c lwz r31,28(r1) <== NOT EXECUTED
ffc21208: 38 21 00 20 addi r1,r1,32 <== NOT EXECUTED
ffc2120c: 4e 80 00 20 blr <== NOT EXECUTED
*/
rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);
if (rc > 0)
return rc;
*result = rtems_rfs_block_get_number (buffer, offset);
ffc21210: 81 3d 00 08 lwz r9,8(r29) <== NOT EXECUTED
ffc21214: 57 e0 10 3a rlwinm r0,r31,2,0,29 <== NOT EXECUTED
ffc21218: 81 69 00 24 lwz r11,36(r9) <== NOT EXECUTED
ffc2121c: 7d 2b 02 14 add r9,r11,r0 <== NOT EXECUTED
ffc21220: 7c 0b 00 ae lbzx r0,r11,r0 <== NOT EXECUTED
ffc21224: 89 49 00 03 lbz r10,3(r9) <== NOT EXECUTED
ffc21228: 89 69 00 01 lbz r11,1(r9) <== NOT EXECUTED
ffc2122c: 54 00 c0 0e rlwinm r0,r0,24,0,7 <== NOT EXECUTED
ffc21230: 89 29 00 02 lbz r9,2(r9) <== NOT EXECUTED
ffc21234: 7d 40 03 78 or r0,r10,r0 <== NOT EXECUTED
ffc21238: 55 6b 80 1e rlwinm r11,r11,16,0,15 <== NOT EXECUTED
ffc2123c: 7c 00 5b 78 or r0,r0,r11 <== NOT EXECUTED
ffc21240: 55 29 40 2e rlwinm r9,r9,8,0,23 <== NOT EXECUTED
ffc21244: 7c 00 4b 78 or r0,r0,r9 <== NOT EXECUTED
if ((*result + 1) == 0)
ffc21248: 2f 80 ff ff cmpwi cr7,r0,-1 <== NOT EXECUTED
ffc2124c: 41 9e 00 5c beq- cr7,ffc212a8 <rtems_rfs_block_find_indirect+0x100><== NOT EXECUTED
*result = 0;
if (*result >= rtems_rfs_fs_blocks (fs))
ffc21250: 81 3e 00 04 lwz r9,4(r30) <== NOT EXECUTED
ffc21254: 38 60 00 00 li r3,0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);
if (rc > 0)
return rc;
*result = rtems_rfs_block_get_number (buffer, offset);
if ((*result + 1) == 0)
ffc21258: 90 1b 00 00 stw r0,0(r27) <== NOT EXECUTED
*result = 0;
if (*result >= rtems_rfs_fs_blocks (fs))
ffc2125c: 7f 80 48 40 cmplw cr7,r0,r9 <== NOT EXECUTED
ffc21260: 41 9c ff 8c blt+ cr7,ffc211ec <rtems_rfs_block_find_indirect+0x44><== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_FIND))
ffc21264: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc21268: 38 80 10 00 li r4,4096 <== NOT EXECUTED
ffc2126c: 4b ff 66 fd bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc21270: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc21274: 40 9e 00 3c bne- cr7,ffc212b0 <rtems_rfs_block_find_indirect+0x108><== NOT EXECUTED
printf ("rtems-rfs: block-find: invalid block in table:"
" block=%" PRId32 ", indirect=%" PRId32 "/%d\n", *result, block, offset);
*result = 0;
ffc21278: 38 00 00 00 li r0,0 <== NOT EXECUTED
rc = EIO;
}
return 0;
}
ffc2127c: 83 81 00 10 lwz r28,16(r1) <== NOT EXECUTED
if (*result >= rtems_rfs_fs_blocks (fs))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_FIND))
printf ("rtems-rfs: block-find: invalid block in table:"
" block=%" PRId32 ", indirect=%" PRId32 "/%d\n", *result, block, offset);
*result = 0;
ffc21280: 90 1b 00 00 stw r0,0(r27) <== NOT EXECUTED
ffc21284: 38 60 00 00 li r3,0 <== NOT EXECUTED
rc = EIO;
}
return 0;
}
ffc21288: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
ffc2128c: 83 61 00 0c lwz r27,12(r1) <== NOT EXECUTED
ffc21290: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc21294: 83 a1 00 14 lwz r29,20(r1) <== NOT EXECUTED
ffc21298: 83 c1 00 18 lwz r30,24(r1) <== NOT EXECUTED
ffc2129c: 83 e1 00 1c lwz r31,28(r1) <== NOT EXECUTED
ffc212a0: 38 21 00 20 addi r1,r1,32 <== NOT EXECUTED
ffc212a4: 4e 80 00 20 blr <== NOT EXECUTED
if (rc > 0)
return rc;
*result = rtems_rfs_block_get_number (buffer, offset);
if ((*result + 1) == 0)
*result = 0;
ffc212a8: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc212ac: 4b ff ff a4 b ffc21250 <rtems_rfs_block_find_indirect+0xa8><== NOT EXECUTED
if (*result >= rtems_rfs_fs_blocks (fs))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_FIND))
printf ("rtems-rfs: block-find: invalid block in table:"
ffc212b0: 80 9b 00 00 lwz r4,0(r27) <== NOT EXECUTED
ffc212b4: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc212b8: 7f 85 e3 78 mr r5,r28 <== NOT EXECUTED
ffc212bc: 7f e6 fb 78 mr r6,r31 <== NOT EXECUTED
ffc212c0: 38 63 c7 84 addi r3,r3,-14460 <== NOT EXECUTED
ffc212c4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc212c8: 48 00 9a 7d bl ffc2ad44 <printf> <== NOT EXECUTED
ffc212cc: 4b ff ff ac b ffc21278 <rtems_rfs_block_find_indirect+0xd0><== NOT EXECUTED
ffc21450 <rtems_rfs_block_get_block_size>:
void
rtems_rfs_block_get_block_size (rtems_rfs_file_system* fs,
rtems_rfs_pos pos,
rtems_rfs_block_size* size)
{
ffc21450: 94 21 ff e8 stwu r1,-24(r1) <== NOT EXECUTED
ffc21454: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc21458: 93 c1 00 10 stw r30,16(r1) <== NOT EXECUTED
ffc2145c: 7c be 2b 78 mr r30,r5 <== NOT EXECUTED
ffc21460: 93 e1 00 14 stw r31,20(r1) <== NOT EXECUTED
ffc21464: 7c df 33 78 mr r31,r6 <== NOT EXECUTED
ffc21468: 90 01 00 1c stw r0,28(r1) <== NOT EXECUTED
if (pos == 0)
ffc2146c: 7f c0 fb 79 or. r0,r30,r31 <== NOT EXECUTED
void
rtems_rfs_block_get_block_size (rtems_rfs_file_system* fs,
rtems_rfs_pos pos,
rtems_rfs_block_size* size)
{
ffc21470: 93 a1 00 0c stw r29,12(r1) <== NOT EXECUTED
ffc21474: 7c fd 3b 78 mr r29,r7 <== NOT EXECUTED
ffc21478: 93 81 00 08 stw r28,8(r1) <== NOT EXECUTED
if (pos == 0)
ffc2147c: 41 82 00 5c beq- ffc214d8 <rtems_rfs_block_get_block_size+0x88><== NOT EXECUTED
rtems_rfs_block_set_size_zero (size);
else
{
size->count = pos / rtems_rfs_fs_block_size (fs) + 1;
ffc21480: 83 83 00 08 lwz r28,8(r3) <== NOT EXECUTED
ffc21484: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc21488: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc2148c: 7f 86 e3 78 mr r6,r28 <== NOT EXECUTED
ffc21490: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc21494: 48 01 6e 09 bl ffc3829c <__udivdi3> <== NOT EXECUTED
size->offset = pos % rtems_rfs_fs_block_size (fs);
ffc21498: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
{
if (pos == 0)
rtems_rfs_block_set_size_zero (size);
else
{
size->count = pos / rtems_rfs_fs_block_size (fs) + 1;
ffc2149c: 38 84 00 01 addi r4,r4,1 <== NOT EXECUTED
ffc214a0: 90 9d 00 00 stw r4,0(r29) <== NOT EXECUTED
size->offset = pos % rtems_rfs_fs_block_size (fs);
ffc214a4: 7f 86 e3 78 mr r6,r28 <== NOT EXECUTED
ffc214a8: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc214ac: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc214b0: 48 01 71 e1 bl ffc38690 <__umoddi3> <== NOT EXECUTED
}
}
ffc214b4: 80 01 00 1c lwz r0,28(r1) <== NOT EXECUTED
if (pos == 0)
rtems_rfs_block_set_size_zero (size);
else
{
size->count = pos / rtems_rfs_fs_block_size (fs) + 1;
size->offset = pos % rtems_rfs_fs_block_size (fs);
ffc214b8: 90 9d 00 04 stw r4,4(r29) <== NOT EXECUTED
}
}
ffc214bc: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc214c0: 83 81 00 08 lwz r28,8(r1) <== NOT EXECUTED
ffc214c4: 83 a1 00 0c lwz r29,12(r1) <== NOT EXECUTED
ffc214c8: 83 c1 00 10 lwz r30,16(r1) <== NOT EXECUTED
ffc214cc: 83 e1 00 14 lwz r31,20(r1) <== NOT EXECUTED
ffc214d0: 38 21 00 18 addi r1,r1,24 <== NOT EXECUTED
ffc214d4: 4e 80 00 20 blr <== NOT EXECUTED
* @param size A pointer to the block size.
*/
static inline void
rtems_rfs_block_set_size_zero (rtems_rfs_block_size* size)
{
size->count = 0;
ffc214d8: 90 07 00 00 stw r0,0(r7) <== NOT EXECUTED
size->offset = 0;
ffc214dc: 90 07 00 04 stw r0,4(r7) <== NOT EXECUTED
ffc214e0: 80 01 00 1c lwz r0,28(r1) <== NOT EXECUTED
ffc214e4: 83 81 00 08 lwz r28,8(r1) <== NOT EXECUTED
ffc214e8: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc214ec: 83 a1 00 0c lwz r29,12(r1) <== NOT EXECUTED
ffc214f0: 83 c1 00 10 lwz r30,16(r1) <== NOT EXECUTED
ffc214f4: 83 e1 00 14 lwz r31,20(r1) <== NOT EXECUTED
ffc214f8: 38 21 00 18 addi r1,r1,24 <== NOT EXECUTED
ffc214fc: 4e 80 00 20 blr <== NOT EXECUTED
ffc21760 <rtems_rfs_block_map_close>:
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
ffc21760: 94 21 ff e8 stwu r1,-24(r1)
ffc21764: 7c 08 02 a6 mflr r0
ffc21768: 90 01 00 1c stw r0,28(r1)
int rc = 0;
int brc;
if (map->dirty && map->inode)
ffc2176c: 88 04 00 00 lbz r0,0(r4)
}
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
ffc21770: 93 81 00 08 stw r28,8(r1)
int rc = 0;
ffc21774: 3b 80 00 00 li r28,0
int brc;
if (map->dirty && map->inode)
ffc21778: 2f 80 00 00 cmpwi cr7,r0,0
}
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
ffc2177c: 93 c1 00 10 stw r30,16(r1)
ffc21780: 7c 7e 1b 78 mr r30,r3
ffc21784: 93 e1 00 14 stw r31,20(r1)
ffc21788: 7c 9f 23 78 mr r31,r4
ffc2178c: 93 a1 00 0c stw r29,12(r1)
int rc = 0;
int brc;
if (map->dirty && map->inode)
ffc21790: 41 9e 00 20 beq- cr7,ffc217b0 <rtems_rfs_block_map_close+0x50>
ffc21794: 80 84 00 04 lwz r4,4(r4)
ffc21798: 2f 84 00 00 cmpwi cr7,r4,0
ffc2179c: 41 9e 00 14 beq- cr7,ffc217b0 <rtems_rfs_block_map_close+0x50><== NEVER TAKEN
{
brc = rtems_rfs_inode_load (fs, map->inode);
ffc217a0: 4b ff 27 65 bl ffc13f04 <rtems_rfs_inode_load>
if (brc > 0)
ffc217a4: 2f 83 00 00 cmpwi cr7,r3,0
ffc217a8: 7c 7c 1b 78 mr r28,r3
ffc217ac: 40 9d 00 60 ble- cr7,ffc2180c <rtems_rfs_block_map_close+0xac><== ALWAYS TAKEN
map->dirty = false;
}
}
map->inode = NULL;
ffc217b0: 3b a0 00 00 li r29,0
ffc217b4: 93 bf 00 04 stw r29,4(r31)
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc217b8: 38 9f 00 38 addi r4,r31,56
ffc217bc: 7f c3 f3 78 mr r3,r30
ffc217c0: 48 00 0e 81 bl ffc22640 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
ffc217c4: 9b bf 00 38 stb r29,56(r31)
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc217c8: 7f c3 f3 78 mr r3,r30
handle->dirty = false;
handle->bnum = 0;
ffc217cc: 93 bf 00 3c stw r29,60(r31)
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc217d0: 38 9f 00 44 addi r4,r31,68
handle->dirty = false;
handle->bnum = 0;
handle->buffer = NULL;
ffc217d4: 93 bf 00 40 stw r29,64(r31)
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc217d8: 48 00 0e 69 bl ffc22640 <rtems_rfs_buffer_handle_release>
rc = brc;
brc = rtems_rfs_buffer_handle_close (fs, &map->doubly_buffer);
if ((brc > 0) && (rc == 0))
rc = brc;
return rc;
}
ffc217dc: 80 01 00 1c lwz r0,28(r1)
handle->dirty = false;
ffc217e0: 9b bf 00 44 stb r29,68(r31)
ffc217e4: 7f 83 e3 78 mr r3,r28
ffc217e8: 7c 08 03 a6 mtlr r0
handle->bnum = 0;
ffc217ec: 93 bf 00 48 stw r29,72(r31)
handle->buffer = NULL;
ffc217f0: 93 bf 00 4c stw r29,76(r31)
ffc217f4: 83 81 00 08 lwz r28,8(r1)
ffc217f8: 83 a1 00 0c lwz r29,12(r1)
ffc217fc: 83 c1 00 10 lwz r30,16(r1)
ffc21800: 83 e1 00 14 lwz r31,20(r1)
ffc21804: 38 21 00 18 addi r1,r1,24
ffc21808: 4e 80 00 20 blr
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc2180c: 38 00 00 05 li r0,5
ffc21810: 7c 09 03 a6 mtctr r0
return rc;
}
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
ffc21814: 38 ff 00 20 addi r7,r31,32
ffc21818: 39 60 00 01 li r11,1
ffc2181c: 39 00 00 00 li r8,0
ffc21820: 38 80 00 01 li r4,1
if (rc == 0)
{
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
ffc21824: 81 3f 00 04 lwz r9,4(r31)
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
ffc21828: 38 c8 00 04 addi r6,r8,4
ffc2182c: 85 47 00 04 lwzu r10,4(r7)
ffc21830: 54 c6 10 3a rlwinm r6,r6,2,0,29
ffc21834: 80 09 00 0c lwz r0,12(r9)
if (rc == 0)
{
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
ffc21838: 39 08 00 01 addi r8,r8,1
ffc2183c: 55 45 c2 3e rlwinm r5,r10,24,8,31
ffc21840: 7c c0 32 14 add r6,r0,r6
ffc21844: 55 40 46 3e rlwinm r0,r10,8,24,31
ffc21848: 98 06 00 0c stb r0,12(r6)
ffc2184c: 55 40 84 3e rlwinm r0,r10,16,16,31
ffc21850: 80 c9 00 0c lwz r6,12(r9)
ffc21854: 7c c6 5a 14 add r6,r6,r11
ffc21858: 98 06 00 1c stb r0,28(r6)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc2185c: 38 00 00 01 li r0,1
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
ffc21860: 80 c9 00 0c lwz r6,12(r9)
ffc21864: 7c c6 5a 14 add r6,r6,r11
ffc21868: 98 a6 00 1d stb r5,29(r6)
ffc2186c: 80 c9 00 0c lwz r6,12(r9)
ffc21870: 7c c6 5a 14 add r6,r6,r11
ffc21874: 99 46 00 1e stb r10,30(r6)
ffc21878: 39 6b 00 04 addi r11,r11,4
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc2187c: 98 89 00 10 stb r4,16(r9)
ffc21880: 42 00 ff a4 bdnz+ ffc21824 <rtems_rfs_block_map_close+0xc4>
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
ffc21884: 81 3f 00 04 lwz r9,4(r31)
rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
brc = rtems_rfs_inode_unload (fs, map->inode, true);
ffc21888: 7f c3 f3 78 mr r3,r30
{
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
ffc2188c: 81 7f 00 08 lwz r11,8(r31)
rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
brc = rtems_rfs_inode_unload (fs, map->inode, true);
ffc21890: 38 a0 00 01 li r5,1
* @param block_count The block count.
*/
static inline void
rtems_rfs_inode_set_block_count (rtems_rfs_inode_handle* handle, uint32_t block_count)
{
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
ffc21894: 81 49 00 0c lwz r10,12(r9)
ffc21898: 55 68 46 3e rlwinm r8,r11,8,24,31
ffc2189c: 99 0a 00 0c stb r8,12(r10)
ffc218a0: 55 67 84 3e rlwinm r7,r11,16,16,31
ffc218a4: 55 68 c2 3e rlwinm r8,r11,24,8,31
ffc218a8: 81 49 00 0c lwz r10,12(r9)
ffc218ac: 98 ea 00 0d stb r7,13(r10)
ffc218b0: 81 49 00 0c lwz r10,12(r9)
ffc218b4: 99 0a 00 0e stb r8,14(r10)
ffc218b8: 81 49 00 0c lwz r10,12(r9)
ffc218bc: 99 6a 00 0f stb r11,15(r10)
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
ffc218c0: 81 5f 00 04 lwz r10,4(r31)
ffc218c4: a1 7f 00 0e lhz r11,14(r31)
*/
static inline void
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,
uint16_t block_offset)
{
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
ffc218c8: 81 0a 00 0c lwz r8,12(r10)
ffc218cc: 55 67 c2 3e rlwinm r7,r11,24,8,31
*/
static inline void
rtems_rfs_inode_set_block_count (rtems_rfs_inode_handle* handle, uint32_t block_count)
{
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc218d0: 98 09 00 10 stb r0,16(r9)
*/
static inline void
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,
uint16_t block_offset)
{
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
ffc218d4: 98 e8 00 0a stb r7,10(r8)
ffc218d8: 81 2a 00 0c lwz r9,12(r10)
ffc218dc: 99 69 00 0b stb r11,11(r9)
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
ffc218e0: 81 7f 00 04 lwz r11,4(r31)
ffc218e4: 81 3f 00 1c lwz r9,28(r31)
* @param block_count The last map block number.
*/
static inline void
rtems_rfs_inode_set_last_map_block (rtems_rfs_inode_handle* handle, uint32_t last_map_block)
{
rtems_rfs_write_u32 (&handle->node->last_map_block, last_map_block);
ffc218e8: 81 0b 00 0c lwz r8,12(r11)
ffc218ec: 55 26 46 3e rlwinm r6,r9,8,24,31
static inline void
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,
uint16_t block_offset)
{
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc218f0: 98 0a 00 10 stb r0,16(r10)
* @param block_count The last map block number.
*/
static inline void
rtems_rfs_inode_set_last_map_block (rtems_rfs_inode_handle* handle, uint32_t last_map_block)
{
rtems_rfs_write_u32 (&handle->node->last_map_block, last_map_block);
ffc218f4: 55 27 84 3e rlwinm r7,r9,16,16,31
ffc218f8: 98 c8 00 30 stb r6,48(r8)
ffc218fc: 55 28 c2 3e rlwinm r8,r9,24,8,31
ffc21900: 81 4b 00 0c lwz r10,12(r11)
ffc21904: 98 ea 00 31 stb r7,49(r10)
ffc21908: 81 4b 00 0c lwz r10,12(r11)
ffc2190c: 99 0a 00 32 stb r8,50(r10)
ffc21910: 81 4b 00 0c lwz r10,12(r11)
ffc21914: 99 2a 00 33 stb r9,51(r10)
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
ffc21918: 81 3f 00 04 lwz r9,4(r31)
ffc2191c: 81 5f 00 20 lwz r10,32(r31)
* @param block_count The last data block number.
*/
static inline void
rtems_rfs_inode_set_last_data_block (rtems_rfs_inode_handle* handle, uint32_t last_data_block)
{
rtems_rfs_write_u32 (&handle->node->last_data_block, last_data_block);
ffc21920: 81 09 00 0c lwz r8,12(r9)
ffc21924: 55 46 46 3e rlwinm r6,r10,8,24,31
*/
static inline void
rtems_rfs_inode_set_last_map_block (rtems_rfs_inode_handle* handle, uint32_t last_map_block)
{
rtems_rfs_write_u32 (&handle->node->last_map_block, last_map_block);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc21928: 98 0b 00 10 stb r0,16(r11)
* @param block_count The last data block number.
*/
static inline void
rtems_rfs_inode_set_last_data_block (rtems_rfs_inode_handle* handle, uint32_t last_data_block)
{
rtems_rfs_write_u32 (&handle->node->last_data_block, last_data_block);
ffc2192c: 55 47 84 3e rlwinm r7,r10,16,16,31
ffc21930: 98 c8 00 34 stb r6,52(r8)
ffc21934: 55 48 c2 3e rlwinm r8,r10,24,8,31
ffc21938: 81 69 00 0c lwz r11,12(r9)
ffc2193c: 98 eb 00 35 stb r7,53(r11)
ffc21940: 81 69 00 0c lwz r11,12(r9)
ffc21944: 99 0b 00 36 stb r8,54(r11)
ffc21948: 81 69 00 0c lwz r11,12(r9)
ffc2194c: 99 4b 00 37 stb r10,55(r11)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc21950: 98 09 00 10 stb r0,16(r9)
brc = rtems_rfs_inode_unload (fs, map->inode, true);
ffc21954: 80 9f 00 04 lwz r4,4(r31)
ffc21958: 4b ff 27 a1 bl ffc140f8 <rtems_rfs_inode_unload>
if (brc > 0)
rc = brc;
map->dirty = false;
ffc2195c: 39 20 00 00 li r9,0
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
brc = rtems_rfs_inode_unload (fs, map->inode, true);
ffc21960: 7c 60 18 f8 not r0,r3
if (brc > 0)
rc = brc;
map->dirty = false;
ffc21964: 99 3f 00 00 stb r9,0(r31)
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
brc = rtems_rfs_inode_unload (fs, map->inode, true);
ffc21968: 7c 00 fe 70 srawi r0,r0,31
ffc2196c: 7c 7c 00 38 and r28,r3,r0
ffc21970: 4b ff fe 40 b ffc217b0 <rtems_rfs_block_map_close+0x50>
ffc21974 <rtems_rfs_block_map_find>:
int
rtems_rfs_block_map_find (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_block_pos* bpos,
rtems_rfs_block_no* block)
{
ffc21974: 94 21 ff d0 stwu r1,-48(r1)
ffc21978: 7c 08 02 a6 mflr r0
ffc2197c: 90 01 00 34 stw r0,52(r1)
int rc = 0;
*block = 0;
ffc21980: 38 00 00 00 li r0,0
int
rtems_rfs_block_map_find (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_block_pos* bpos,
rtems_rfs_block_no* block)
{
ffc21984: 93 61 00 1c stw r27,28(r1)
ffc21988: 93 81 00 20 stw r28,32(r1)
ffc2198c: 7c 7c 1b 78 mr r28,r3
ffc21990: 93 a1 00 24 stw r29,36(r1)
ffc21994: 7c dd 33 78 mr r29,r6
ffc21998: 93 c1 00 28 stw r30,40(r1)
ffc2199c: 7c be 2b 78 mr r30,r5
ffc219a0: 93 e1 00 2c stw r31,44(r1)
ffc219a4: 7c 9f 23 78 mr r31,r4
int rc = 0;
*block = 0;
ffc219a8: 90 06 00 00 stw r0,0(r6)
/*
* Range checking here makes the remaining logic simpler.
*/
if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))
ffc219ac: 83 65 00 00 lwz r27,0(r5)
ffc219b0: 80 04 00 08 lwz r0,8(r4)
ffc219b4: 2f 9b 00 00 cmpwi cr7,r27,0
ffc219b8: 41 9e 00 34 beq- cr7,ffc219ec <rtems_rfs_block_map_find+0x78>
ffc219bc: 2f 80 00 00 cmpwi cr7,r0,0
return ENXIO;
ffc219c0: 38 60 00 06 li r3,6
*block = 0;
/*
* Range checking here makes the remaining logic simpler.
*/
if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))
ffc219c4: 40 9e 00 28 bne- cr7,ffc219ec <rtems_rfs_block_map_find+0x78><== ALWAYS TAKEN
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
map->bpos.block = *block;
}
return rc;
}
ffc219c8: 80 01 00 34 lwz r0,52(r1)
ffc219cc: 83 61 00 1c lwz r27,28(r1)
ffc219d0: 7c 08 03 a6 mtlr r0
ffc219d4: 83 81 00 20 lwz r28,32(r1)
ffc219d8: 83 a1 00 24 lwz r29,36(r1)
ffc219dc: 83 c1 00 28 lwz r30,40(r1)
ffc219e0: 83 e1 00 2c lwz r31,44(r1)
ffc219e4: 38 21 00 30 addi r1,r1,48
ffc219e8: 4e 80 00 20 blr
*block = 0;
/*
* Range checking here makes the remaining logic simpler.
*/
if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))
ffc219ec: 7f 9b 00 40 cmplw cr7,r27,r0
return ENXIO;
ffc219f0: 38 60 00 06 li r3,6
*block = 0;
/*
* Range checking here makes the remaining logic simpler.
*/
if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))
ffc219f4: 40 9c ff d4 bge+ cr7,ffc219c8 <rtems_rfs_block_map_find+0x54>
return ENXIO;
/*
* If the block position is the same and we have found the block just return it.
*/
if ((bpos->bno == map->bpos.bno) && (map->bpos.block != 0))
ffc219f8: 81 3f 00 10 lwz r9,16(r31)
ffc219fc: 7f 9b 48 00 cmpw cr7,r27,r9
ffc21a00: 41 9e 00 68 beq- cr7,ffc21a68 <rtems_rfs_block_map_find+0xf4><== ALWAYS TAKEN
/*
* Determine the type of access we need to perform. If the number of blocks
* is less than or equal to the number of slots in the inode the blocks are
* directly accessed.
*/
if (map->size.count <= RTEMS_RFS_INODE_BLOCKS)
ffc21a04: 2b 80 00 05 cmplwi cr7,r0,5
ffc21a08: 41 9d 00 74 bgt- cr7,ffc21a7c <rtems_rfs_block_map_find+0x108><== NEVER TAKEN
{
*block = map->blocks[bpos->bno];
ffc21a0c: 3b 7b 00 08 addi r27,r27,8
ffc21a10: 57 7b 10 3a rlwinm r27,r27,2,0,29
ffc21a14: 7f 7f da 14 add r27,r31,r27
ffc21a18: 80 1b 00 04 lwz r0,4(r27)
ffc21a1c: 90 1d 00 00 stw r0,0(r29)
}
}
if (rc == 0)
{
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
ffc21a20: 81 7e 00 08 lwz r11,8(r30)
map->bpos.block = *block;
ffc21a24: 38 60 00 00 li r3,0
}
}
if (rc == 0)
{
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
ffc21a28: 80 1e 00 04 lwz r0,4(r30)
ffc21a2c: 81 3e 00 00 lwz r9,0(r30)
ffc21a30: 91 7f 00 18 stw r11,24(r31)
ffc21a34: 91 3f 00 10 stw r9,16(r31)
ffc21a38: 90 1f 00 14 stw r0,20(r31)
map->bpos.block = *block;
ffc21a3c: 80 1d 00 00 lwz r0,0(r29)
}
return rc;
}
ffc21a40: 83 61 00 1c lwz r27,28(r1)
}
if (rc == 0)
{
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
map->bpos.block = *block;
ffc21a44: 90 1f 00 18 stw r0,24(r31)
}
return rc;
}
ffc21a48: 80 01 00 34 lwz r0,52(r1)
ffc21a4c: 83 81 00 20 lwz r28,32(r1)
ffc21a50: 7c 08 03 a6 mtlr r0
ffc21a54: 83 a1 00 24 lwz r29,36(r1)
ffc21a58: 83 c1 00 28 lwz r30,40(r1)
ffc21a5c: 83 e1 00 2c lwz r31,44(r1)
ffc21a60: 38 21 00 30 addi r1,r1,48
ffc21a64: 4e 80 00 20 blr
return ENXIO;
/*
* If the block position is the same and we have found the block just return it.
*/
if ((bpos->bno == map->bpos.bno) && (map->bpos.block != 0))
ffc21a68: 81 3f 00 18 lwz r9,24(r31)
ffc21a6c: 2f 89 00 00 cmpwi cr7,r9,0
ffc21a70: 41 be ff 94 beq- cr7,ffc21a04 <rtems_rfs_block_map_find+0x90><== ALWAYS TAKEN
{
*block = map->bpos.block;
ffc21a74: 91 3d 00 00 stw r9,0(r29) <== NOT EXECUTED
ffc21a78: 4b ff ff a8 b ffc21a20 <rtems_rfs_block_map_find+0xac><== NOT EXECUTED
* The map is either singly or doubly indirect.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = bpos->bno % fs->blocks_per_block;
ffc21a7c: 80 dc 00 30 lwz r6,48(r28) <== NOT EXECUTED
singly = bpos->bno / fs->blocks_per_block;
if (map->size.count <= fs->block_map_singly_blocks)
ffc21a80: 81 7c 00 34 lwz r11,52(r28) <== NOT EXECUTED
* The map is either singly or doubly indirect.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = bpos->bno % fs->blocks_per_block;
ffc21a84: 7d 3b 33 96 divwu r9,r27,r6 <== NOT EXECUTED
singly = bpos->bno / fs->blocks_per_block;
if (map->size.count <= fs->block_map_singly_blocks)
ffc21a88: 7f 8b 00 40 cmplw cr7,r11,r0 <== NOT EXECUTED
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = bpos->bno % fs->blocks_per_block;
singly = bpos->bno / fs->blocks_per_block;
ffc21a8c: 91 21 00 08 stw r9,8(r1) <== NOT EXECUTED
* The map is either singly or doubly indirect.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = bpos->bno % fs->blocks_per_block;
ffc21a90: 7d 69 31 d6 mullw r11,r9,r6 <== NOT EXECUTED
ffc21a94: 7f 6b d8 50 subf r27,r11,r27 <== NOT EXECUTED
singly = bpos->bno / fs->blocks_per_block;
if (map->size.count <= fs->block_map_singly_blocks)
ffc21a98: 40 9c 00 70 bge- cr7,ffc21b08 <rtems_rfs_block_map_find+0x194><== NOT EXECUTED
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
ffc21a9c: 7d 69 33 96 divwu r11,r9,r6 <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
ffc21aa0: 81 5c 00 38 lwz r10,56(r28) <== NOT EXECUTED
ffc21aa4: 7f 8a 00 40 cmplw cr7,r10,r0 <== NOT EXECUTED
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
ffc21aa8: 7c cb 31 d6 mullw r6,r11,r6 <== NOT EXECUTED
{
/*
* This should never happen. Here so Joel can remove once his coverage
* testing gets to the file systems.
*/
rc = ENXIO;
ffc21aac: 38 60 00 06 li r3,6 <== NOT EXECUTED
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
ffc21ab0: 7c c6 48 50 subf r6,r6,r9 <== NOT EXECUTED
ffc21ab4: 90 c1 00 08 stw r6,8(r1) <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
ffc21ab8: 40 9d ff 10 ble+ cr7,ffc219c8 <rtems_rfs_block_map_find+0x54><== NOT EXECUTED
{
rc = rtems_rfs_block_find_indirect (fs,
ffc21abc: 39 2b 00 08 addi r9,r11,8 <== NOT EXECUTED
ffc21ac0: 55 29 10 3a rlwinm r9,r9,2,0,29 <== NOT EXECUTED
ffc21ac4: 7d 3f 4a 14 add r9,r31,r9 <== NOT EXECUTED
ffc21ac8: 80 a9 00 04 lwz r5,4(r9) <== NOT EXECUTED
ffc21acc: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc21ad0: 38 9f 00 44 addi r4,r31,68 <== NOT EXECUTED
ffc21ad4: 38 e1 00 08 addi r7,r1,8 <== NOT EXECUTED
ffc21ad8: 4b ff f6 d1 bl ffc211a8 <rtems_rfs_block_find_indirect><== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
singly, &singly);
if (rc == 0)
ffc21adc: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc21ae0: 40 82 fe e8 bne+ ffc219c8 <rtems_rfs_block_map_find+0x54><== NOT EXECUTED
{
rc = rtems_rfs_block_find_indirect (fs,
ffc21ae4: 80 a1 00 08 lwz r5,8(r1) <== NOT EXECUTED
ffc21ae8: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc21aec: 38 9f 00 38 addi r4,r31,56 <== NOT EXECUTED
ffc21af0: 7f 66 db 78 mr r6,r27 <== NOT EXECUTED
ffc21af4: 7f a7 eb 78 mr r7,r29 <== NOT EXECUTED
ffc21af8: 4b ff f6 b1 bl ffc211a8 <rtems_rfs_block_find_indirect><== NOT EXECUTED
}
}
}
}
if (rc == 0)
ffc21afc: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc21b00: 40 9e fe c8 bne+ cr7,ffc219c8 <rtems_rfs_block_map_find+0x54><== NOT EXECUTED
ffc21b04: 4b ff ff 1c b ffc21a20 <rtems_rfs_block_map_find+0xac><== NOT EXECUTED
{
/*
* This is a single indirect table of blocks anchored off a slot in the
* inode.
*/
rc = rtems_rfs_block_find_indirect (fs,
ffc21b08: 39 29 00 08 addi r9,r9,8 <== NOT EXECUTED
ffc21b0c: 55 29 10 3a rlwinm r9,r9,2,0,29 <== NOT EXECUTED
ffc21b10: 7d 3f 4a 14 add r9,r31,r9 <== NOT EXECUTED
ffc21b14: 80 a9 00 04 lwz r5,4(r9) <== NOT EXECUTED
ffc21b18: 4b ff ff d0 b ffc21ae8 <rtems_rfs_block_map_find+0x174><== NOT EXECUTED
ffc21c20 <rtems_rfs_block_map_grow>:
int
rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks,
rtems_rfs_block_no* new_block)
{
ffc21c20: 94 21 ff b8 stwu r1,-72(r1)
ffc21c24: 7c 08 02 a6 mflr r0
ffc21c28: 93 a1 00 3c stw r29,60(r1)
ffc21c2c: 7c 7d 1b 78 mr r29,r3
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
ffc21c30: 38 60 00 00 li r3,0
int
rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks,
rtems_rfs_block_no* new_block)
{
ffc21c34: 93 e1 00 44 stw r31,68(r1)
ffc21c38: 7c 9f 23 78 mr r31,r4
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
ffc21c3c: 38 80 20 00 li r4,8192
int
rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks,
rtems_rfs_block_no* new_block)
{
ffc21c40: 92 e1 00 24 stw r23,36(r1)
ffc21c44: 7c d7 33 78 mr r23,r6
ffc21c48: 93 41 00 30 stw r26,48(r1)
ffc21c4c: 7c ba 2b 78 mr r26,r5
ffc21c50: 90 01 00 4c stw r0,76(r1)
ffc21c54: 92 81 00 18 stw r20,24(r1)
ffc21c58: 92 a1 00 1c stw r21,28(r1)
ffc21c5c: 92 c1 00 20 stw r22,32(r1)
ffc21c60: 93 01 00 28 stw r24,40(r1)
ffc21c64: 93 21 00 2c stw r25,44(r1)
ffc21c68: 93 61 00 34 stw r27,52(r1)
ffc21c6c: 93 81 00 38 stw r28,56(r1)
ffc21c70: 93 c1 00 40 stw r30,64(r1)
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
ffc21c74: 4b ff 5c f5 bl ffc17968 <rtems_rfs_trace>
ffc21c78: 2f 83 00 00 cmpwi cr7,r3,0
ffc21c7c: 40 9e 03 a8 bne- cr7,ffc22024 <rtems_rfs_block_map_grow+0x404><== NEVER TAKEN
printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
blocks, map->size.count);
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
ffc21c80: 81 3f 00 08 lwz r9,8(r31)
return EFBIG;
ffc21c84: 3a 80 00 1b li r20,27
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
blocks, map->size.count);
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
ffc21c88: 80 1d 00 38 lwz r0,56(r29)
ffc21c8c: 7d 3a 4a 14 add r9,r26,r9
ffc21c90: 7f 89 00 40 cmplw cr7,r9,r0
ffc21c94: 41 9c 00 48 blt- cr7,ffc21cdc <rtems_rfs_block_map_grow+0xbc><== ALWAYS TAKEN
map->last_data_block = block;
map->dirty = true;
}
return 0;
}
ffc21c98: 80 01 00 4c lwz r0,76(r1)
ffc21c9c: 7e 83 a3 78 mr r3,r20
ffc21ca0: 82 a1 00 1c lwz r21,28(r1)
ffc21ca4: 7c 08 03 a6 mtlr r0
ffc21ca8: 82 81 00 18 lwz r20,24(r1)
ffc21cac: 82 c1 00 20 lwz r22,32(r1)
ffc21cb0: 82 e1 00 24 lwz r23,36(r1)
ffc21cb4: 83 01 00 28 lwz r24,40(r1)
ffc21cb8: 83 21 00 2c lwz r25,44(r1)
ffc21cbc: 83 41 00 30 lwz r26,48(r1)
ffc21cc0: 83 61 00 34 lwz r27,52(r1)
ffc21cc4: 83 81 00 38 lwz r28,56(r1)
ffc21cc8: 83 a1 00 3c lwz r29,60(r1)
ffc21ccc: 83 c1 00 40 lwz r30,64(r1)
ffc21cd0: 83 e1 00 44 lwz r31,68(r1)
ffc21cd4: 38 21 00 48 addi r1,r1,72
ffc21cd8: 4e 80 00 20 blr
/*
* Allocate a block at a time. The buffer handles hold the blocks so adding
* this way does not thrash the cache with lots of requests.
*/
for (b = 0; b < blocks; b++)
ffc21cdc: 2f 9a 00 00 cmpwi cr7,r26,0
*new_block = block;
map->last_data_block = block;
map->dirty = true;
}
return 0;
ffc21ce0: 3a 80 00 00 li r20,0
/*
* Allocate a block at a time. The buffer handles hold the blocks so adding
* this way does not thrash the cache with lots of requests.
*/
for (b = 0; b < blocks; b++)
ffc21ce4: 41 be ff b4 beq- cr7,ffc21c98 <rtems_rfs_block_map_grow+0x78><== NEVER TAKEN
ffc21ce8: 80 9f 00 20 lwz r4,32(r31)
map->last_map_block = new_block;
return 0;
}
int
rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,
ffc21cec: 3b c0 00 00 li r30,0
return rc;
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
ffc21cf0: 3b 80 00 01 li r28,1
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
ffc21cf4: 3a bf 00 44 addi r21,r31,68
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
ffc21cf8: 3a df 00 38 addi r22,r31,56
ffc21cfc: 48 00 00 48 b ffc21d44 <rtems_rfs_block_map_grow+0x124>
false, &block);
if (rc > 0)
return rc;
if (map->size.count < RTEMS_RFS_INODE_BLOCKS)
map->blocks[map->size.count] = block;
ffc21d00: 39 27 00 08 addi r9,r7,8
ffc21d04: 80 81 00 0c lwz r4,12(r1)
ffc21d08: 55 29 10 3a rlwinm r9,r9,2,0,29
ffc21d0c: 7d 3f 4a 14 add r9,r31,r9
ffc21d10: 90 89 00 04 stw r4,4(r9)
}
map->size.count++;
map->size.offset = 0;
if (b == 0)
ffc21d14: 2f 9e 00 00 cmpwi cr7,r30,0
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
}
map->size.count++;
ffc21d18: 38 e7 00 01 addi r7,r7,1
map->size.offset = 0;
ffc21d1c: 38 00 00 00 li r0,0
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
}
map->size.count++;
ffc21d20: 90 ff 00 08 stw r7,8(r31)
map->size.offset = 0;
ffc21d24: 90 1f 00 0c stw r0,12(r31)
if (b == 0)
ffc21d28: 40 9e 00 08 bne- cr7,ffc21d30 <rtems_rfs_block_map_grow+0x110><== NEVER TAKEN
*new_block = block;
ffc21d2c: 90 97 00 00 stw r4,0(r23)
/*
* Allocate a block at a time. The buffer handles hold the blocks so adding
* this way does not thrash the cache with lots of requests.
*/
for (b = 0; b < blocks; b++)
ffc21d30: 3b de 00 01 addi r30,r30,1
map->size.count++;
map->size.offset = 0;
if (b == 0)
*new_block = block;
map->last_data_block = block;
ffc21d34: 90 9f 00 20 stw r4,32(r31)
/*
* Allocate a block at a time. The buffer handles hold the blocks so adding
* this way does not thrash the cache with lots of requests.
*/
for (b = 0; b < blocks; b++)
ffc21d38: 7f 9e d0 00 cmpw cr7,r30,r26
map->size.offset = 0;
if (b == 0)
*new_block = block;
map->last_data_block = block;
map->dirty = true;
ffc21d3c: 9b 9f 00 00 stb r28,0(r31)
/*
* Allocate a block at a time. The buffer handles hold the blocks so adding
* this way does not thrash the cache with lots of requests.
*/
for (b = 0; b < blocks; b++)
ffc21d40: 41 9e 03 00 beq- cr7,ffc22040 <rtems_rfs_block_map_grow+0x420><== ALWAYS TAKEN
/*
* Allocate the block. If an indirect block is needed and cannot be
* allocated free this block.
*/
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_data_block,
ffc21d44: 7f a3 eb 78 mr r3,r29
ffc21d48: 38 a0 00 00 li r5,0
ffc21d4c: 38 c1 00 0c addi r6,r1,12
ffc21d50: 4b ff 1b 95 bl ffc138e4 <rtems_rfs_group_bitmap_alloc>
false, &block);
if (rc > 0)
ffc21d54: 7c 74 1b 79 mr. r20,r3
ffc21d58: 41 a1 ff 40 bgt- ffc21c98 <rtems_rfs_block_map_grow+0x78><== NEVER TAKEN
return rc;
if (map->size.count < RTEMS_RFS_INODE_BLOCKS)
ffc21d5c: 80 ff 00 08 lwz r7,8(r31)
ffc21d60: 2b 87 00 04 cmplwi cr7,r7,4
ffc21d64: 40 bd ff 9c ble- cr7,ffc21d00 <rtems_rfs_block_map_grow+0xe0><== ALWAYS TAKEN
* Single indirect access is occuring. It could still be doubly indirect.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = map->size.count % fs->blocks_per_block;
ffc21d68: 80 1d 00 30 lwz r0,48(r29) <== NOT EXECUTED
singly = map->size.count / fs->blocks_per_block;
if (map->size.count < fs->block_map_singly_blocks)
ffc21d6c: 81 3d 00 34 lwz r9,52(r29) <== NOT EXECUTED
* Single indirect access is occuring. It could still be doubly indirect.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = map->size.count % fs->blocks_per_block;
ffc21d70: 7c c7 03 96 divwu r6,r7,r0 <== NOT EXECUTED
singly = map->size.count / fs->blocks_per_block;
if (map->size.count < fs->block_map_singly_blocks)
ffc21d74: 7f 87 48 40 cmplw cr7,r7,r9 <== NOT EXECUTED
* Single indirect access is occuring. It could still be doubly indirect.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = map->size.count % fs->blocks_per_block;
ffc21d78: 7f 66 01 d6 mullw r27,r6,r0 <== NOT EXECUTED
ffc21d7c: 7f 7b 38 50 subf r27,r27,r7 <== NOT EXECUTED
singly = map->size.count / fs->blocks_per_block;
if (map->size.count < fs->block_map_singly_blocks)
ffc21d80: 40 9c 00 ac bge- cr7,ffc21e2c <rtems_rfs_block_map_grow+0x20c><== NOT EXECUTED
* Singly indirect tables are being used. Allocate a new block for a
* mapping table if direct is 0 or we are moving up (upping). If upping
* move the direct blocks into the table and if not this is the first
* entry of a new block.
*/
if ((direct == 0) ||
ffc21d84: 2f 9b 00 00 cmpwi cr7,r27,0 <== NOT EXECUTED
ffc21d88: 41 9e 02 08 beq- cr7,ffc21f90 <rtems_rfs_block_map_grow+0x370><== NOT EXECUTED
ffc21d8c: 2f 86 00 00 cmpwi cr7,r6,0 <== NOT EXECUTED
ffc21d90: 40 9e 00 0c bne- cr7,ffc21d9c <rtems_rfs_block_map_grow+0x17c><== NOT EXECUTED
((singly == 0) && (direct == RTEMS_RFS_INODE_BLOCKS)))
ffc21d94: 2f 9b 00 05 cmpwi cr7,r27,5 <== NOT EXECUTED
ffc21d98: 41 9e 01 f8 beq- cr7,ffc21f90 <rtems_rfs_block_map_grow+0x370><== NOT EXECUTED
&map->blocks[singly],
upping);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
ffc21d9c: 38 c6 00 08 addi r6,r6,8 <== NOT EXECUTED
ffc21da0: 54 c6 10 3a rlwinm r6,r6,2,0,29 <== NOT EXECUTED
ffc21da4: 7c df 32 14 add r6,r31,r6 <== NOT EXECUTED
ffc21da8: 80 a6 00 04 lwz r5,4(r6) <== NOT EXECUTED
ffc21dac: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc21db0: 7e c4 b3 78 mr r4,r22 <== NOT EXECUTED
ffc21db4: 38 c0 00 01 li r6,1 <== NOT EXECUTED
ffc21db8: 48 00 0a 9d bl ffc22854 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
ffc21dbc: 7c 74 1b 78 mr r20,r3 <== NOT EXECUTED
map->blocks[singly], true);
}
if (rc > 0)
ffc21dc0: 2f 94 00 00 cmpwi cr7,r20,0 <== NOT EXECUTED
ffc21dc4: 41 9d 01 b8 bgt- cr7,ffc21f7c <rtems_rfs_block_map_grow+0x35c><== NOT EXECUTED
return rc;
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
ffc21dc8: 81 3f 00 40 lwz r9,64(r31) <== NOT EXECUTED
ffc21dcc: 57 7b 10 3a rlwinm r27,r27,2,0,29 <== NOT EXECUTED
ffc21dd0: 88 01 00 0c lbz r0,12(r1) <== NOT EXECUTED
ffc21dd4: 81 29 00 24 lwz r9,36(r9) <== NOT EXECUTED
ffc21dd8: 7c 09 d9 ae stbx r0,r9,r27 <== NOT EXECUTED
ffc21ddc: 81 3f 00 40 lwz r9,64(r31) <== NOT EXECUTED
ffc21de0: a0 01 00 0c lhz r0,12(r1) <== NOT EXECUTED
ffc21de4: 81 29 00 24 lwz r9,36(r9) <== NOT EXECUTED
ffc21de8: 7d 29 da 14 add r9,r9,r27 <== NOT EXECUTED
ffc21dec: 98 09 00 01 stb r0,1(r9) <== NOT EXECUTED
ffc21df0: 81 3f 00 40 lwz r9,64(r31) <== NOT EXECUTED
ffc21df4: 80 01 00 0c lwz r0,12(r1) <== NOT EXECUTED
ffc21df8: 81 29 00 24 lwz r9,36(r9) <== NOT EXECUTED
ffc21dfc: 54 00 c2 3e rlwinm r0,r0,24,8,31 <== NOT EXECUTED
ffc21e00: 7d 29 da 14 add r9,r9,r27 <== NOT EXECUTED
ffc21e04: 98 09 00 02 stb r0,2(r9) <== NOT EXECUTED
ffc21e08: 81 3f 00 40 lwz r9,64(r31) <== NOT EXECUTED
ffc21e0c: 80 09 00 24 lwz r0,36(r9) <== NOT EXECUTED
ffc21e10: 7f 60 da 14 add r27,r0,r27 <== NOT EXECUTED
ffc21e14: 80 01 00 0c lwz r0,12(r1) <== NOT EXECUTED
ffc21e18: 98 1b 00 03 stb r0,3(r27) <== NOT EXECUTED
ffc21e1c: 9b 9f 00 38 stb r28,56(r31) <== NOT EXECUTED
ffc21e20: 80 ff 00 08 lwz r7,8(r31) <== NOT EXECUTED
ffc21e24: 80 81 00 0c lwz r4,12(r1) <== NOT EXECUTED
ffc21e28: 4b ff fe ec b ffc21d14 <rtems_rfs_block_map_grow+0xf4><== NOT EXECUTED
* Doubly indirect tables are being used.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no singly_block;
doubly = singly / fs->blocks_per_block;
ffc21e2c: 7f 26 03 96 divwu r25,r6,r0 <== NOT EXECUTED
* Allocate a new block for a singly indirect table if direct is 0 as
* it is the first entry of a new block. We may also need to allocate a
* doubly indirect block as well. Both always occur when direct is 0
* and the doubly indirect block when singly is 0.
*/
if (direct == 0)
ffc21e30: 2f 9b 00 00 cmpwi cr7,r27,0 <== NOT EXECUTED
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no singly_block;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
ffc21e34: 7f 19 01 d6 mullw r24,r25,r0 <== NOT EXECUTED
ffc21e38: 7f 18 30 50 subf r24,r24,r6 <== NOT EXECUTED
* Allocate a new block for a singly indirect table if direct is 0 as
* it is the first entry of a new block. We may also need to allocate a
* doubly indirect block as well. Both always occur when direct is 0
* and the doubly indirect block when singly is 0.
*/
if (direct == 0)
ffc21e3c: 40 9e 00 c0 bne- cr7,ffc21efc <rtems_rfs_block_map_grow+0x2dc><== NOT EXECUTED
{
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
ffc21e40: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc21e44: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc21e48: 7e c5 b3 78 mr r5,r22 <== NOT EXECUTED
ffc21e4c: 38 c1 00 08 addi r6,r1,8 <== NOT EXECUTED
ffc21e50: 38 e0 00 00 li r7,0 <== NOT EXECUTED
ffc21e54: 4b ff f1 8d bl ffc20fe0 <rtems_rfs_block_map_indirect_alloc><== NOT EXECUTED
&map->singly_buffer,
&singly_block,
false);
if (rc > 0)
ffc21e58: 7c 74 1b 79 mr. r20,r3 <== NOT EXECUTED
ffc21e5c: 41 81 01 20 bgt- ffc21f7c <rtems_rfs_block_map_grow+0x35c><== NOT EXECUTED
/*
* Allocate a new block for a doubly indirect table if singly is 0 as
* it is the first entry of a new singly indirect block.
*/
if ((singly == 0) ||
ffc21e60: 2f 98 00 00 cmpwi cr7,r24,0 <== NOT EXECUTED
ffc21e64: 41 9e 01 60 beq- cr7,ffc21fc4 <rtems_rfs_block_map_grow+0x3a4><== NOT EXECUTED
ffc21e68: 2f 99 00 00 cmpwi cr7,r25,0 <== NOT EXECUTED
ffc21e6c: 40 9e 00 0c bne- cr7,ffc21e78 <rtems_rfs_block_map_grow+0x258><== NOT EXECUTED
((doubly == 0) && (singly == RTEMS_RFS_INODE_BLOCKS)))
ffc21e70: 2f 98 00 05 cmpwi cr7,r24,5 <== NOT EXECUTED
ffc21e74: 41 9e 01 50 beq- cr7,ffc21fc4 <rtems_rfs_block_map_grow+0x3a4><== NOT EXECUTED
return rc;
}
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
ffc21e78: 3b 39 00 08 addi r25,r25,8 <== NOT EXECUTED
ffc21e7c: 57 39 10 3a rlwinm r25,r25,2,0,29 <== NOT EXECUTED
ffc21e80: 7f 3f ca 14 add r25,r31,r25 <== NOT EXECUTED
ffc21e84: 80 b9 00 04 lwz r5,4(r25) <== NOT EXECUTED
ffc21e88: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc21e8c: 7e a4 ab 78 mr r4,r21 <== NOT EXECUTED
ffc21e90: 38 c0 00 01 li r6,1 <== NOT EXECUTED
ffc21e94: 48 00 09 c1 bl ffc22854 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
ffc21e98: 7c 74 1b 79 mr. r20,r3 <== NOT EXECUTED
ffc21e9c: 41 81 01 64 bgt- ffc22000 <rtems_rfs_block_map_grow+0x3e0><== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
}
rtems_rfs_block_set_number (&map->doubly_buffer,
ffc21ea0: 81 3f 00 4c lwz r9,76(r31) <== NOT EXECUTED
ffc21ea4: 57 18 10 3a rlwinm r24,r24,2,0,29 <== NOT EXECUTED
ffc21ea8: 88 01 00 08 lbz r0,8(r1) <== NOT EXECUTED
ffc21eac: 81 29 00 24 lwz r9,36(r9) <== NOT EXECUTED
ffc21eb0: 7c 09 c1 ae stbx r0,r9,r24 <== NOT EXECUTED
ffc21eb4: 81 3f 00 4c lwz r9,76(r31) <== NOT EXECUTED
ffc21eb8: a0 01 00 08 lhz r0,8(r1) <== NOT EXECUTED
ffc21ebc: 81 29 00 24 lwz r9,36(r9) <== NOT EXECUTED
ffc21ec0: 7d 29 c2 14 add r9,r9,r24 <== NOT EXECUTED
ffc21ec4: 98 09 00 01 stb r0,1(r9) <== NOT EXECUTED
ffc21ec8: 81 3f 00 4c lwz r9,76(r31) <== NOT EXECUTED
ffc21ecc: 80 01 00 08 lwz r0,8(r1) <== NOT EXECUTED
ffc21ed0: 81 29 00 24 lwz r9,36(r9) <== NOT EXECUTED
ffc21ed4: 54 00 c2 3e rlwinm r0,r0,24,8,31 <== NOT EXECUTED
ffc21ed8: 7d 29 c2 14 add r9,r9,r24 <== NOT EXECUTED
ffc21edc: 98 09 00 02 stb r0,2(r9) <== NOT EXECUTED
ffc21ee0: 81 3f 00 4c lwz r9,76(r31) <== NOT EXECUTED
ffc21ee4: 80 09 00 24 lwz r0,36(r9) <== NOT EXECUTED
ffc21ee8: 7f 00 c2 14 add r24,r0,r24 <== NOT EXECUTED
ffc21eec: 80 01 00 08 lwz r0,8(r1) <== NOT EXECUTED
ffc21ef0: 98 18 00 03 stb r0,3(r24) <== NOT EXECUTED
ffc21ef4: 9b 9f 00 44 stb r28,68(r31) <== NOT EXECUTED
ffc21ef8: 4b ff fe d0 b ffc21dc8 <rtems_rfs_block_map_grow+0x1a8><== NOT EXECUTED
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
ffc21efc: 3b 39 00 08 addi r25,r25,8 <== NOT EXECUTED
ffc21f00: 57 39 10 3a rlwinm r25,r25,2,0,29 <== NOT EXECUTED
ffc21f04: 7f 3f ca 14 add r25,r31,r25 <== NOT EXECUTED
ffc21f08: 80 b9 00 04 lwz r5,4(r25) <== NOT EXECUTED
ffc21f0c: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc21f10: 7e a4 ab 78 mr r4,r21 <== NOT EXECUTED
ffc21f14: 38 c0 00 01 li r6,1 <== NOT EXECUTED
ffc21f18: 48 00 09 3d bl ffc22854 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
true);
if (rc > 0)
ffc21f1c: 7c 74 1b 79 mr. r20,r3 <== NOT EXECUTED
ffc21f20: 41 81 00 5c bgt- ffc21f7c <rtems_rfs_block_map_grow+0x35c><== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
ffc21f24: 81 3f 00 4c lwz r9,76(r31) <== NOT EXECUTED
ffc21f28: 57 18 10 3a rlwinm r24,r24,2,0,29 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
ffc21f2c: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
ffc21f30: 81 69 00 24 lwz r11,36(r9) <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
ffc21f34: 7e c4 b3 78 mr r4,r22 <== NOT EXECUTED
ffc21f38: 38 c0 00 01 li r6,1 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
ffc21f3c: 7c 0b c0 ae lbzx r0,r11,r24 <== NOT EXECUTED
ffc21f40: 7d 2b c2 14 add r9,r11,r24 <== NOT EXECUTED
ffc21f44: 89 49 00 03 lbz r10,3(r9) <== NOT EXECUTED
ffc21f48: 89 69 00 01 lbz r11,1(r9) <== NOT EXECUTED
ffc21f4c: 54 00 c0 0e rlwinm r0,r0,24,0,7 <== NOT EXECUTED
ffc21f50: 89 29 00 02 lbz r9,2(r9) <== NOT EXECUTED
ffc21f54: 7d 40 03 78 or r0,r10,r0 <== NOT EXECUTED
ffc21f58: 55 6b 80 1e rlwinm r11,r11,16,0,15 <== NOT EXECUTED
ffc21f5c: 7c 00 5b 78 or r0,r0,r11 <== NOT EXECUTED
ffc21f60: 55 29 40 2e rlwinm r9,r9,8,0,23 <== NOT EXECUTED
ffc21f64: 7c 00 4b 78 or r0,r0,r9 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
ffc21f68: 7c 05 03 78 mr r5,r0 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
ffc21f6c: 90 01 00 08 stw r0,8(r1) <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
ffc21f70: 48 00 08 e5 bl ffc22854 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
singly_block, true);
if (rc > 0)
ffc21f74: 7c 74 1b 79 mr. r20,r3 <== NOT EXECUTED
ffc21f78: 40 81 fe 50 ble+ ffc21dc8 <rtems_rfs_block_map_grow+0x1a8><== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
ffc21f7c: 80 a1 00 0c lwz r5,12(r1) <== NOT EXECUTED
ffc21f80: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc21f84: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc21f88: 4b ff 1b d5 bl ffc13b5c <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
return rc;
ffc21f8c: 4b ff fd 0c b ffc21c98 <rtems_rfs_block_map_grow+0x78><== NOT EXECUTED
/*
* Upping is when we move from direct to singly indirect.
*/
bool upping;
upping = map->size.count == RTEMS_RFS_INODE_BLOCKS;
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
ffc21f90: 38 c6 00 08 addi r6,r6,8 <== NOT EXECUTED
ffc21f94: 54 c6 10 3a rlwinm r6,r6,2,0,29 <== NOT EXECUTED
ffc21f98: 68 e7 00 05 xori r7,r7,5 <== NOT EXECUTED
ffc21f9c: 7c df 32 14 add r6,r31,r6 <== NOT EXECUTED
ffc21fa0: 7c e7 00 34 cntlzw r7,r7 <== NOT EXECUTED
ffc21fa4: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc21fa8: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc21fac: 7e c5 b3 78 mr r5,r22 <== NOT EXECUTED
ffc21fb0: 38 c6 00 04 addi r6,r6,4 <== NOT EXECUTED
ffc21fb4: 54 e7 d9 7e rlwinm r7,r7,27,5,31 <== NOT EXECUTED
ffc21fb8: 4b ff f0 29 bl ffc20fe0 <rtems_rfs_block_map_indirect_alloc><== NOT EXECUTED
ffc21fbc: 7c 74 1b 78 mr r20,r3 <== NOT EXECUTED
* move the direct blocks into the table and if not this is the first
* entry of a new block.
*/
if ((direct == 0) ||
((singly == 0) && (direct == RTEMS_RFS_INODE_BLOCKS)))
{
ffc21fc0: 4b ff fe 00 b ffc21dc0 <rtems_rfs_block_map_grow+0x1a0><== NOT EXECUTED
*/
if ((singly == 0) ||
((doubly == 0) && (singly == RTEMS_RFS_INODE_BLOCKS)))
{
bool upping;
upping = map->size.count == fs->block_map_singly_blocks;
ffc21fc4: 80 ff 00 08 lwz r7,8(r31) <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
ffc21fc8: 38 d9 00 08 addi r6,r25,8 <== NOT EXECUTED
*/
if ((singly == 0) ||
((doubly == 0) && (singly == RTEMS_RFS_INODE_BLOCKS)))
{
bool upping;
upping = map->size.count == fs->block_map_singly_blocks;
ffc21fcc: 80 1d 00 34 lwz r0,52(r29) <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
ffc21fd0: 54 c6 10 3a rlwinm r6,r6,2,0,29 <== NOT EXECUTED
ffc21fd4: 7c df 32 14 add r6,r31,r6 <== NOT EXECUTED
ffc21fd8: 7c e7 02 78 xor r7,r7,r0 <== NOT EXECUTED
ffc21fdc: 7c e7 00 34 cntlzw r7,r7 <== NOT EXECUTED
ffc21fe0: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc21fe4: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc21fe8: 7e a5 ab 78 mr r5,r21 <== NOT EXECUTED
ffc21fec: 38 c6 00 04 addi r6,r6,4 <== NOT EXECUTED
ffc21ff0: 54 e7 d9 7e rlwinm r7,r7,27,5,31 <== NOT EXECUTED
ffc21ff4: 4b ff ef ed bl ffc20fe0 <rtems_rfs_block_map_indirect_alloc><== NOT EXECUTED
&map->doubly_buffer,
&map->blocks[doubly],
upping);
if (rc > 0)
ffc21ff8: 7c 74 1b 79 mr. r20,r3 <== NOT EXECUTED
ffc21ffc: 40 81 fe a4 ble+ ffc21ea0 <rtems_rfs_block_map_grow+0x280><== NOT EXECUTED
{
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
map->blocks[doubly], true);
if (rc > 0)
{
rtems_rfs_group_bitmap_free (fs, false, singly_block);
ffc22000: 80 a1 00 08 lwz r5,8(r1) <== NOT EXECUTED
ffc22004: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc22008: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc2200c: 4b ff 1b 51 bl ffc13b5c <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, block);
ffc22010: 80 a1 00 0c lwz r5,12(r1) <== NOT EXECUTED
ffc22014: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc22018: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc2201c: 4b ff 1b 41 bl ffc13b5c <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
return rc;
ffc22020: 4b ff fc 78 b ffc21c98 <rtems_rfs_block_map_grow+0x78><== NOT EXECUTED
rtems_rfs_block_no* new_block)
{
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
ffc22024: 80 bf 00 08 lwz r5,8(r31) <== NOT EXECUTED
ffc22028: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc2202c: 7f 44 d3 78 mr r4,r26 <== NOT EXECUTED
ffc22030: 38 63 c7 d0 addi r3,r3,-14384 <== NOT EXECUTED
ffc22034: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc22038: 48 00 8d 0d bl ffc2ad44 <printf> <== NOT EXECUTED
ffc2203c: 4b ff fc 44 b ffc21c80 <rtems_rfs_block_map_grow+0x60><== NOT EXECUTED
*new_block = block;
map->last_data_block = block;
map->dirty = true;
}
return 0;
ffc22040: 3a 80 00 00 li r20,0
ffc22044: 4b ff fc 54 b ffc21c98 <rtems_rfs_block_map_grow+0x78>
ffc20fe0 <rtems_rfs_block_map_indirect_alloc>:
rtems_rfs_block_map_indirect_alloc (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no* block,
bool upping)
{
ffc20fe0: 94 21 ff d0 stwu r1,-48(r1) <== NOT EXECUTED
ffc20fe4: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc20fe8: 90 01 00 34 stw r0,52(r1) <== NOT EXECUTED
ffc20fec: 93 e1 00 2c stw r31,44(r1) <== NOT EXECUTED
ffc20ff0: 7c 9f 23 78 mr r31,r4 <== NOT EXECUTED
int rc;
/*
* Save the new block locally because upping can have *block pointing to the
* slots which are cleared when upping.
*/
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_map_block, false, &new_block);
ffc20ff4: 80 84 00 1c lwz r4,28(r4) <== NOT EXECUTED
rtems_rfs_block_map_indirect_alloc (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no* block,
bool upping)
{
ffc20ff8: 93 81 00 20 stw r28,32(r1) <== NOT EXECUTED
ffc20ffc: 7c dc 33 78 mr r28,r6 <== NOT EXECUTED
int rc;
/*
* Save the new block locally because upping can have *block pointing to the
* slots which are cleared when upping.
*/
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_map_block, false, &new_block);
ffc21000: 38 c1 00 08 addi r6,r1,8 <== NOT EXECUTED
rtems_rfs_block_map_indirect_alloc (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no* block,
bool upping)
{
ffc21004: 93 c1 00 28 stw r30,40(r1) <== NOT EXECUTED
ffc21008: 7c be 2b 78 mr r30,r5 <== NOT EXECUTED
int rc;
/*
* Save the new block locally because upping can have *block pointing to the
* slots which are cleared when upping.
*/
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_map_block, false, &new_block);
ffc2100c: 38 a0 00 00 li r5,0 <== NOT EXECUTED
rtems_rfs_block_map_indirect_alloc (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no* block,
bool upping)
{
ffc21010: 93 41 00 18 stw r26,24(r1) <== NOT EXECUTED
ffc21014: 93 61 00 1c stw r27,28(r1) <== NOT EXECUTED
ffc21018: 7c fb 3b 78 mr r27,r7 <== NOT EXECUTED
ffc2101c: 93 a1 00 24 stw r29,36(r1) <== NOT EXECUTED
ffc21020: 7c 7d 1b 78 mr r29,r3 <== NOT EXECUTED
int rc;
/*
* Save the new block locally because upping can have *block pointing to the
* slots which are cleared when upping.
*/
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_map_block, false, &new_block);
ffc21024: 4b ff 28 c1 bl ffc138e4 <rtems_rfs_group_bitmap_alloc><== NOT EXECUTED
if (rc > 0)
ffc21028: 7c 7a 1b 79 mr. r26,r3 <== NOT EXECUTED
ffc2102c: 40 81 00 30 ble- ffc2105c <rtems_rfs_block_map_indirect_alloc+0x7c><== NOT EXECUTED
}
rtems_rfs_buffer_mark_dirty (buffer);
*block = new_block;
map->last_map_block = new_block;
return 0;
}
ffc21030: 80 01 00 34 lwz r0,52(r1) <== NOT EXECUTED
ffc21034: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc21038: 83 61 00 1c lwz r27,28(r1) <== NOT EXECUTED
ffc2103c: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc21040: 83 41 00 18 lwz r26,24(r1) <== NOT EXECUTED
ffc21044: 83 81 00 20 lwz r28,32(r1) <== NOT EXECUTED
ffc21048: 83 a1 00 24 lwz r29,36(r1) <== NOT EXECUTED
ffc2104c: 83 c1 00 28 lwz r30,40(r1) <== NOT EXECUTED
ffc21050: 83 e1 00 2c lwz r31,44(r1) <== NOT EXECUTED
ffc21054: 38 21 00 30 addi r1,r1,48 <== NOT EXECUTED
ffc21058: 4e 80 00 20 blr <== NOT EXECUTED
* slots which are cleared when upping.
*/
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_map_block, false, &new_block);
if (rc > 0)
return rc;
rc = rtems_rfs_buffer_handle_request (fs, buffer, new_block, false);
ffc2105c: 80 a1 00 08 lwz r5,8(r1) <== NOT EXECUTED
ffc21060: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc21064: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc21068: 38 c0 00 00 li r6,0 <== NOT EXECUTED
ffc2106c: 48 00 17 e9 bl ffc22854 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
if (rc > 0)
ffc21070: 7c 7a 1b 79 mr. r26,r3 <== NOT EXECUTED
ffc21074: 40 81 00 40 ble- ffc210b4 <rtems_rfs_block_map_indirect_alloc+0xd4><== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, new_block);
ffc21078: 80 a1 00 08 lwz r5,8(r1) <== NOT EXECUTED
ffc2107c: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc21080: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc21084: 4b ff 2a d9 bl ffc13b5c <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
}
rtems_rfs_buffer_mark_dirty (buffer);
*block = new_block;
map->last_map_block = new_block;
return 0;
}
ffc21088: 80 01 00 34 lwz r0,52(r1) <== NOT EXECUTED
ffc2108c: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc21090: 83 61 00 1c lwz r27,28(r1) <== NOT EXECUTED
ffc21094: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc21098: 83 41 00 18 lwz r26,24(r1) <== NOT EXECUTED
ffc2109c: 83 81 00 20 lwz r28,32(r1) <== NOT EXECUTED
ffc210a0: 83 a1 00 24 lwz r29,36(r1) <== NOT EXECUTED
ffc210a4: 83 c1 00 28 lwz r30,40(r1) <== NOT EXECUTED
ffc210a8: 83 e1 00 2c lwz r31,44(r1) <== NOT EXECUTED
ffc210ac: 38 21 00 30 addi r1,r1,48 <== NOT EXECUTED
ffc210b0: 4e 80 00 20 blr <== NOT EXECUTED
if (rc > 0)
{
rtems_rfs_group_bitmap_free (fs, false, new_block);
return rc;
}
memset (rtems_rfs_buffer_data (buffer), 0xff, rtems_rfs_fs_block_size (fs));
ffc210b4: 81 3e 00 08 lwz r9,8(r30) <== NOT EXECUTED
ffc210b8: 38 80 00 ff li r4,255 <== NOT EXECUTED
ffc210bc: 80 bd 00 08 lwz r5,8(r29) <== NOT EXECUTED
ffc210c0: 80 69 00 24 lwz r3,36(r9) <== NOT EXECUTED
ffc210c4: 48 00 9a f1 bl ffc2abb4 <memset> <== NOT EXECUTED
if (upping)
ffc210c8: 2f 9b 00 00 cmpwi cr7,r27,0 <== NOT EXECUTED
ffc210cc: 40 9e 00 20 bne- cr7,ffc210ec <rtems_rfs_block_map_indirect_alloc+0x10c><== NOT EXECUTED
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
}
rtems_rfs_buffer_mark_dirty (buffer);
*block = new_block;
ffc210d0: 80 01 00 08 lwz r0,8(r1) <== NOT EXECUTED
map->size.count);
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
}
rtems_rfs_buffer_mark_dirty (buffer);
ffc210d4: 39 20 00 01 li r9,1 <== NOT EXECUTED
ffc210d8: 99 3e 00 00 stb r9,0(r30) <== NOT EXECUTED
*block = new_block;
map->last_map_block = new_block;
return 0;
ffc210dc: 3b 40 00 00 li r26,0 <== NOT EXECUTED
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
}
rtems_rfs_buffer_mark_dirty (buffer);
*block = new_block;
ffc210e0: 90 1c 00 00 stw r0,0(r28) <== NOT EXECUTED
map->last_map_block = new_block;
ffc210e4: 90 1f 00 1c stw r0,28(r31) <== NOT EXECUTED
return 0;
ffc210e8: 4b ff ff 48 b ffc21030 <rtems_rfs_block_map_indirect_alloc+0x50><== NOT EXECUTED
}
memset (rtems_rfs_buffer_data (buffer), 0xff, rtems_rfs_fs_block_size (fs));
if (upping)
{
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
ffc210ec: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc210f0: 38 80 20 00 li r4,8192 <== NOT EXECUTED
ffc210f4: 4b ff 68 75 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc210f8: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc210fc: 40 9e 00 94 bne- cr7,ffc21190 <rtems_rfs_block_map_indirect_alloc+0x1b0><== NOT EXECUTED
printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
map->size.count);
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
ffc21100: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc21104: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
* @param block The block number of the indirect block allocated.
* @param upping True is upping the map to the next indirect level.
* @return int The error number (errno). No error if 0.
*/
static int
rtems_rfs_block_map_indirect_alloc (rtems_rfs_file_system* fs,
ffc21108: 39 7f 00 20 addi r11,r31,32 <== NOT EXECUTED
ffc2110c: 39 20 00 00 li r9,0 <== NOT EXECUTED
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
map->size.count);
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
ffc21110: 39 00 00 01 li r8,1 <== NOT EXECUTED
ffc21114: 81 5e 00 08 lwz r10,8(r30) <== NOT EXECUTED
ffc21118: 84 0b 00 04 lwzu r0,4(r11) <== NOT EXECUTED
ffc2111c: 81 4a 00 24 lwz r10,36(r10) <== NOT EXECUTED
ffc21120: 54 00 46 3e rlwinm r0,r0,8,24,31 <== NOT EXECUTED
ffc21124: 7c 0a 49 ae stbx r0,r10,r9 <== NOT EXECUTED
ffc21128: 81 5e 00 08 lwz r10,8(r30) <== NOT EXECUTED
ffc2112c: a0 0b 00 00 lhz r0,0(r11) <== NOT EXECUTED
ffc21130: 81 4a 00 24 lwz r10,36(r10) <== NOT EXECUTED
ffc21134: 7d 4a 4a 14 add r10,r10,r9 <== NOT EXECUTED
ffc21138: 98 0a 00 01 stb r0,1(r10) <== NOT EXECUTED
ffc2113c: 81 5e 00 08 lwz r10,8(r30) <== NOT EXECUTED
ffc21140: 80 0b 00 00 lwz r0,0(r11) <== NOT EXECUTED
ffc21144: 81 4a 00 24 lwz r10,36(r10) <== NOT EXECUTED
ffc21148: 54 00 c2 3e rlwinm r0,r0,24,8,31 <== NOT EXECUTED
ffc2114c: 7d 4a 4a 14 add r10,r10,r9 <== NOT EXECUTED
ffc21150: 98 0a 00 02 stb r0,2(r10) <== NOT EXECUTED
ffc21154: 81 5e 00 08 lwz r10,8(r30) <== NOT EXECUTED
ffc21158: 80 0b 00 00 lwz r0,0(r11) <== NOT EXECUTED
ffc2115c: 81 4a 00 24 lwz r10,36(r10) <== NOT EXECUTED
ffc21160: 7d 4a 4a 14 add r10,r10,r9 <== NOT EXECUTED
ffc21164: 98 0a 00 03 stb r0,3(r10) <== NOT EXECUTED
ffc21168: 39 29 00 04 addi r9,r9,4 <== NOT EXECUTED
ffc2116c: 99 1e 00 00 stb r8,0(r30) <== NOT EXECUTED
{
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
map->size.count);
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
ffc21170: 42 00 ff a4 bdnz+ ffc21114 <rtems_rfs_block_map_indirect_alloc+0x134><== NOT EXECUTED
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
ffc21174: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc21178: 90 1f 00 24 stw r0,36(r31) <== NOT EXECUTED
ffc2117c: 90 1f 00 28 stw r0,40(r31) <== NOT EXECUTED
ffc21180: 90 1f 00 2c stw r0,44(r31) <== NOT EXECUTED
ffc21184: 90 1f 00 30 stw r0,48(r31) <== NOT EXECUTED
ffc21188: 90 1f 00 34 stw r0,52(r31) <== NOT EXECUTED
ffc2118c: 4b ff ff 44 b ffc210d0 <rtems_rfs_block_map_indirect_alloc+0xf0><== NOT EXECUTED
memset (rtems_rfs_buffer_data (buffer), 0xff, rtems_rfs_fs_block_size (fs));
if (upping)
{
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
ffc21190: 80 9f 00 08 lwz r4,8(r31) <== NOT EXECUTED
ffc21194: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc21198: 38 63 c7 50 addi r3,r3,-14512 <== NOT EXECUTED
ffc2119c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc211a0: 48 00 9b a5 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc211a4: 4b ff ff 5c b ffc21100 <rtems_rfs_block_map_indirect_alloc+0x120><== NOT EXECUTED
ffc212d0 <rtems_rfs_block_map_indirect_shrink.isra.12>:
* block to be freed and the indirect block is now also free, or we have only
* one indirect table and we can fit the remaining blocks into the inode,
* then either move to the next indirect block or move the remaining blocks
* into the inode and free the indirect table's block.
*/
if ((index == 0) ||
ffc212d0: 2c 07 00 00 cmpwi r7,0 <== NOT EXECUTED
* @param indirect The index index in the inode's block table.
* @param index The index in the indirect table of the block.
* @return int The error number (errno). No error if 0.
*/
static int
rtems_rfs_block_map_indirect_shrink (rtems_rfs_file_system* fs,
ffc212d4: 94 21 ff f0 stwu r1,-16(r1) <== NOT EXECUTED
ffc212d8: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc212dc: 93 e1 00 0c stw r31,12(r1) <== NOT EXECUTED
ffc212e0: 7c 9f 23 78 mr r31,r4 <== NOT EXECUTED
ffc212e4: 90 01 00 14 stw r0,20(r1) <== NOT EXECUTED
ffc212e8: 93 c1 00 08 stw r30,8(r1) <== NOT EXECUTED
* block to be freed and the indirect block is now also free, or we have only
* one indirect table and we can fit the remaining blocks into the inode,
* then either move to the next indirect block or move the remaining blocks
* into the inode and free the indirect table's block.
*/
if ((index == 0) ||
ffc212ec: 41 82 00 34 beq- ffc21320 <rtems_rfs_block_map_indirect_shrink.isra.12+0x50><== NOT EXECUTED
ffc212f0: 2f 86 00 00 cmpwi cr7,r6,0 <== NOT EXECUTED
rtems_rfs_block_map* map,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no indirect,
rtems_rfs_block_no index)
{
int rc = 0;
ffc212f4: 38 00 00 00 li r0,0 <== NOT EXECUTED
* block to be freed and the indirect block is now also free, or we have only
* one indirect table and we can fit the remaining blocks into the inode,
* then either move to the next indirect block or move the remaining blocks
* into the inode and free the indirect table's block.
*/
if ((index == 0) ||
ffc212f8: 40 9e 00 0c bne- cr7,ffc21304 <rtems_rfs_block_map_indirect_shrink.isra.12+0x34><== NOT EXECUTED
((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))
ffc212fc: 2f 87 00 05 cmpwi cr7,r7,5 <== NOT EXECUTED
ffc21300: 41 9e 00 68 beq- cr7,ffc21368 <rtems_rfs_block_map_indirect_shrink.isra.12+0x98><== NOT EXECUTED
map->last_map_block = block_to_free;
}
return rc;
}
ffc21304: 7c 03 03 78 mr r3,r0 <== NOT EXECUTED
ffc21308: 80 01 00 14 lwz r0,20(r1) <== NOT EXECUTED
ffc2130c: 83 c1 00 08 lwz r30,8(r1) <== NOT EXECUTED
ffc21310: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc21314: 83 e1 00 0c lwz r31,12(r1) <== NOT EXECUTED
ffc21318: 38 21 00 10 addi r1,r1,16 <== NOT EXECUTED
ffc2131c: 4e 80 00 20 blr <== NOT EXECUTED
* into the inode and free the indirect table's block.
*/
if ((index == 0) ||
((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))
{
rtems_rfs_block_no block_to_free = map->blocks[indirect];
ffc21320: 38 c6 00 08 addi r6,r6,8 <== NOT EXECUTED
ffc21324: 54 c6 10 3a rlwinm r6,r6,2,0,29 <== NOT EXECUTED
ffc21328: 7c c4 32 14 add r6,r4,r6 <== NOT EXECUTED
ffc2132c: 83 c6 00 04 lwz r30,4(r6) <== NOT EXECUTED
else
{
/*
* One less singly indirect block in the inode.
*/
map->blocks[indirect] = 0;
ffc21330: 90 e6 00 04 stw r7,4(r6) <== NOT EXECUTED
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
ffc21334: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc21338: 7f c5 f3 78 mr r5,r30 <== NOT EXECUTED
ffc2133c: 4b ff 28 21 bl ffc13b5c <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
if (rc > 0)
ffc21340: 7c 60 1b 79 mr. r0,r3 <== NOT EXECUTED
ffc21344: 41 81 ff c0 bgt+ ffc21304 <rtems_rfs_block_map_indirect_shrink.isra.12+0x34><== NOT EXECUTED
map->last_map_block = block_to_free;
}
return rc;
}
ffc21348: 7c 03 03 78 mr r3,r0 <== NOT EXECUTED
ffc2134c: 80 01 00 14 lwz r0,20(r1) <== NOT EXECUTED
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
if (rc > 0)
return rc;
map->last_map_block = block_to_free;
ffc21350: 93 df 00 1c stw r30,28(r31) <== NOT EXECUTED
}
return rc;
}
ffc21354: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc21358: 83 c1 00 08 lwz r30,8(r1) <== NOT EXECUTED
ffc2135c: 83 e1 00 0c lwz r31,12(r1) <== NOT EXECUTED
ffc21360: 38 21 00 10 addi r1,r1,16 <== NOT EXECUTED
ffc21364: 4e 80 00 20 blr <== NOT EXECUTED
* @param indirect The index index in the inode's block table.
* @param index The index in the indirect table of the block.
* @return int The error number (errno). No error if 0.
*/
static int
rtems_rfs_block_map_indirect_shrink (rtems_rfs_file_system* fs,
ffc21368: 38 00 00 05 li r0,5 <== NOT EXECUTED
* into the inode and free the indirect table's block.
*/
if ((index == 0) ||
((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))
{
rtems_rfs_block_no block_to_free = map->blocks[indirect];
ffc2136c: 81 25 00 00 lwz r9,0(r5) <== NOT EXECUTED
* @param indirect The index index in the inode's block table.
* @param index The index in the indirect table of the block.
* @return int The error number (errno). No error if 0.
*/
static int
rtems_rfs_block_map_indirect_shrink (rtems_rfs_file_system* fs,
ffc21370: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
* into the inode and free the indirect table's block.
*/
if ((index == 0) ||
((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))
{
rtems_rfs_block_no block_to_free = map->blocks[indirect];
ffc21374: 83 c4 00 24 lwz r30,36(r4) <== NOT EXECUTED
ffc21378: 81 29 00 24 lwz r9,36(r9) <== NOT EXECUTED
* @param indirect The index index in the inode's block table.
* @param index The index in the indirect table of the block.
* @return int The error number (errno). No error if 0.
*/
static int
rtems_rfs_block_map_indirect_shrink (rtems_rfs_file_system* fs,
ffc2137c: 39 64 00 20 addi r11,r4,32 <== NOT EXECUTED
/*
* Move to direct inode access.
*/
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
map->blocks[b] = rtems_rfs_block_get_number (buffer, b);
ffc21380: 88 e9 00 00 lbz r7,0(r9) <== NOT EXECUTED
ffc21384: 88 09 00 01 lbz r0,1(r9) <== NOT EXECUTED
ffc21388: 89 09 00 03 lbz r8,3(r9) <== NOT EXECUTED
ffc2138c: 54 e7 c0 0e rlwinm r7,r7,24,0,7 <== NOT EXECUTED
ffc21390: 89 49 00 02 lbz r10,2(r9) <== NOT EXECUTED
ffc21394: 54 00 80 1e rlwinm r0,r0,16,0,15 <== NOT EXECUTED
ffc21398: 7c e0 03 78 or r0,r7,r0 <== NOT EXECUTED
ffc2139c: 7c 00 43 78 or r0,r0,r8 <== NOT EXECUTED
ffc213a0: 55 4a 40 2e rlwinm r10,r10,8,0,23 <== NOT EXECUTED
ffc213a4: 7c 00 53 78 or r0,r0,r10 <== NOT EXECUTED
ffc213a8: 94 0b 00 04 stwu r0,4(r11) <== NOT EXECUTED
{
/*
* Move to direct inode access.
*/
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
ffc213ac: 39 29 00 04 addi r9,r9,4 <== NOT EXECUTED
ffc213b0: 42 00 ff d0 bdnz+ ffc21380 <rtems_rfs_block_map_indirect_shrink.isra.12+0xb0><== NOT EXECUTED
ffc213b4: 4b ff ff 80 b ffc21334 <rtems_rfs_block_map_indirect_shrink.isra.12+0x64><== NOT EXECUTED
ffc21558 <rtems_rfs_block_map_open>:
int
rtems_rfs_block_map_open (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* inode,
rtems_rfs_block_map* map)
{
ffc21558: 94 21 ff e0 stwu r1,-32(r1)
ffc2155c: 7c 08 02 a6 mflr r0
ffc21560: 93 c1 00 18 stw r30,24(r1)
* sure the inode has been loaded into memory. If we did not load the inode
* do not unload it. The caller may assume it is still loaded when we return.
*/
map->dirty = false;
map->inode = NULL;
ffc21564: 3b c0 00 00 li r30,0
int
rtems_rfs_block_map_open (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* inode,
rtems_rfs_block_map* map)
{
ffc21568: 90 01 00 24 stw r0,36(r1)
* Set the count to 0 so at least find fails, then open the handle and make
* sure the inode has been loaded into memory. If we did not load the inode
* do not unload it. The caller may assume it is still loaded when we return.
*/
map->dirty = false;
ffc2156c: 38 00 00 00 li r0,0
int
rtems_rfs_block_map_open (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* inode,
rtems_rfs_block_map* map)
{
ffc21570: 93 61 00 0c stw r27,12(r1)
ffc21574: 7c 7b 1b 78 mr r27,r3
ffc21578: 93 81 00 10 stw r28,16(r1)
ffc2157c: 93 a1 00 14 stw r29,20(r1)
ffc21580: 7c 9d 23 78 mr r29,r4
ffc21584: 93 e1 00 1c stw r31,28(r1)
ffc21588: 7c bf 2b 78 mr r31,r5
* Set the count to 0 so at least find fails, then open the handle and make
* sure the inode has been loaded into memory. If we did not load the inode
* do not unload it. The caller may assume it is still loaded when we return.
*/
map->dirty = false;
ffc2158c: 98 05 00 00 stb r0,0(r5)
map->inode = NULL;
ffc21590: 93 c5 00 04 stw r30,4(r5)
* @param size A pointer to the block size.
*/
static inline void
rtems_rfs_block_set_size_zero (rtems_rfs_block_size* size)
{
size->count = 0;
ffc21594: 93 c5 00 08 stw r30,8(r5)
size->offset = 0;
ffc21598: 93 c5 00 0c stw r30,12(r5)
* @param bpos A pointer to the block position.
*/
static inline void
rtems_rfs_block_set_bpos_zero (rtems_rfs_block_pos* bpos)
{
bpos->bno = 0;
ffc2159c: 93 c5 00 10 stw r30,16(r5)
bpos->boff = 0;
ffc215a0: 93 c5 00 14 stw r30,20(r5)
bpos->block = 0;
ffc215a4: 93 c5 00 18 stw r30,24(r5)
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc215a8: 9b c5 00 38 stb r30,56(r5)
handle->bnum = 0;
ffc215ac: 93 c5 00 3c stw r30,60(r5)
handle->buffer = NULL;
ffc215b0: 93 c5 00 40 stw r30,64(r5)
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc215b4: 9b c5 00 44 stb r30,68(r5)
handle->bnum = 0;
ffc215b8: 93 c5 00 48 stw r30,72(r5)
handle->buffer = NULL;
ffc215bc: 93 c5 00 4c stw r30,76(r5)
return rc;
rc = rtems_rfs_buffer_handle_open (fs, &map->doubly_buffer);
if (rc > 0)
return rc;
rc = rtems_rfs_inode_load (fs, inode);
ffc215c0: 4b ff 29 45 bl ffc13f04 <rtems_rfs_inode_load>
if (rc > 0)
ffc215c4: 7c 7c 1b 79 mr. r28,r3
ffc215c8: 41 81 01 40 bgt- ffc21708 <rtems_rfs_block_map_open+0x1b0><== NEVER TAKEN
ffc215cc: 38 00 00 05 li r0,5
/*
* Extract the block and block count data from the inode into the targets
* byte order.
*/
map->inode = inode;
ffc215d0: 81 3d 00 0c lwz r9,12(r29)
ffc215d4: 7c 09 03 a6 mtctr r0
ffc215d8: 93 bf 00 04 stw r29,4(r31)
block_size = rtems_rfs_fs_block_size (fs);
return (((uint64_t) (size->count - 1)) * block_size) + offset;
}
int
rtems_rfs_block_map_open (rtems_rfs_file_system* fs,
ffc215dc: 38 df 00 20 addi r6,r31,32
ffc215e0: 39 60 00 01 li r11,1
/*
* Extract the block and block count data from the inode into the targets
* byte order.
*/
map->inode = inode;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
ffc215e4: 39 40 00 00 li r10,0
ffc215e8: 38 e9 00 1c addi r7,r9,28
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
ffc215ec: 38 aa 00 04 addi r5,r10,4
ffc215f0: 54 a5 10 3a rlwinm r5,r5,2,0,29
ffc215f4: 7c a9 2a 14 add r5,r9,r5
ffc215f8: 7d 07 5a 14 add r8,r7,r11
ffc215fc: 88 05 00 0c lbz r0,12(r5)
ffc21600: 88 88 00 02 lbz r4,2(r8)
ffc21604: 39 4a 00 01 addi r10,r10,1
ffc21608: 7c a7 58 ae lbzx r5,r7,r11
ffc2160c: 54 00 c0 0e rlwinm r0,r0,24,0,7
ffc21610: 89 08 00 01 lbz r8,1(r8)
ffc21614: 7c 80 03 78 or r0,r4,r0
ffc21618: 54 a5 80 1e rlwinm r5,r5,16,0,15
ffc2161c: 7c 00 2b 78 or r0,r0,r5
ffc21620: 55 08 40 2e rlwinm r8,r8,8,0,23
ffc21624: 7c 00 43 78 or r0,r0,r8
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
ffc21628: 94 06 00 04 stwu r0,4(r6)
/*
* Extract the block and block count data from the inode into the targets
* byte order.
*/
map->inode = inode;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
ffc2162c: 39 6b 00 04 addi r11,r11,4
ffc21630: 42 00 ff bc bdnz+ ffc215ec <rtems_rfs_block_map_open+0x94>
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
ffc21634: 89 09 00 0c lbz r8,12(r9)
map->size.count = rtems_rfs_inode_get_block_count (inode);
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
rc = rtems_rfs_inode_unload (fs, inode, false);
ffc21638: 7f 63 db 78 mr r3,r27
ffc2163c: 88 09 00 0d lbz r0,13(r9)
ffc21640: 7f a4 eb 78 mr r4,r29
ffc21644: 89 49 00 0f lbz r10,15(r9)
ffc21648: 55 08 c0 0e rlwinm r8,r8,24,0,7
ffc2164c: 89 69 00 0e lbz r11,14(r9)
ffc21650: 54 00 80 1e rlwinm r0,r0,16,0,15
ffc21654: 7d 00 03 78 or r0,r8,r0
ffc21658: 7c 00 53 78 or r0,r0,r10
ffc2165c: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc21660: 7c 00 5b 78 or r0,r0,r11
* byte order.
*/
map->inode = inode;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
map->size.count = rtems_rfs_inode_get_block_count (inode);
ffc21664: 90 1f 00 08 stw r0,8(r31)
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
rc = rtems_rfs_inode_unload (fs, inode, false);
ffc21668: 38 a0 00 00 li r5,0
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
ffc2166c: 88 09 00 0a lbz r0,10(r9)
ffc21670: 89 69 00 0b lbz r11,11(r9)
ffc21674: 54 00 40 2e rlwinm r0,r0,8,0,23
*/
map->inode = inode;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
map->size.count = rtems_rfs_inode_get_block_count (inode);
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
ffc21678: 7c 00 5b 78 or r0,r0,r11
ffc2167c: 90 1f 00 0c stw r0,12(r31)
* @return uint32_t The last map block number.
*/
static inline uint32_t
rtems_rfs_inode_get_last_map_block (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->last_map_block);
ffc21680: 89 09 00 30 lbz r8,48(r9)
ffc21684: 88 09 00 31 lbz r0,49(r9)
ffc21688: 89 49 00 33 lbz r10,51(r9)
ffc2168c: 55 08 c0 0e rlwinm r8,r8,24,0,7
ffc21690: 89 69 00 32 lbz r11,50(r9)
ffc21694: 54 00 80 1e rlwinm r0,r0,16,0,15
ffc21698: 7d 00 03 78 or r0,r8,r0
ffc2169c: 7c 00 53 78 or r0,r0,r10
ffc216a0: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc216a4: 7c 00 5b 78 or r0,r0,r11
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
ffc216a8: 90 1f 00 1c stw r0,28(r31)
* @return uint32_t The last data block number.
*/
static inline uint32_t
rtems_rfs_inode_get_last_data_block (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->last_data_block);
ffc216ac: 89 49 00 34 lbz r10,52(r9)
ffc216b0: 88 09 00 35 lbz r0,53(r9)
ffc216b4: 89 69 00 37 lbz r11,55(r9)
ffc216b8: 55 4a c0 0e rlwinm r10,r10,24,0,7
ffc216bc: 89 29 00 36 lbz r9,54(r9)
ffc216c0: 54 00 80 1e rlwinm r0,r0,16,0,15
ffc216c4: 7d 40 03 78 or r0,r10,r0
ffc216c8: 7c 00 5b 78 or r0,r0,r11
ffc216cc: 55 29 40 2e rlwinm r9,r9,8,0,23
ffc216d0: 7c 00 4b 78 or r0,r0,r9
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
ffc216d4: 90 1f 00 20 stw r0,32(r31)
rc = rtems_rfs_inode_unload (fs, inode, false);
ffc216d8: 4b ff 2a 21 bl ffc140f8 <rtems_rfs_inode_unload>
return rc;
}
ffc216dc: 80 01 00 24 lwz r0,36(r1)
map->size.count = rtems_rfs_inode_get_block_count (inode);
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
rc = rtems_rfs_inode_unload (fs, inode, false);
ffc216e0: 7c 7c 1b 78 mr r28,r3
return rc;
}
ffc216e4: 83 61 00 0c lwz r27,12(r1)
ffc216e8: 7c 08 03 a6 mtlr r0
ffc216ec: 7f 83 e3 78 mr r3,r28
ffc216f0: 83 a1 00 14 lwz r29,20(r1)
ffc216f4: 83 81 00 10 lwz r28,16(r1)
ffc216f8: 83 c1 00 18 lwz r30,24(r1)
ffc216fc: 83 e1 00 1c lwz r31,28(r1)
ffc21700: 38 21 00 20 addi r1,r1,32
ffc21704: 4e 80 00 20 blr
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc21708: 38 9f 00 38 addi r4,r31,56 <== NOT EXECUTED
ffc2170c: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc21710: 48 00 0f 31 bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
ffc21714: 9b df 00 38 stb r30,56(r31) <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc21718: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
ffc2171c: 93 df 00 3c stw r30,60(r31) <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc21720: 38 9f 00 44 addi r4,r31,68 <== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
handle->buffer = NULL;
ffc21724: 93 df 00 40 stw r30,64(r31) <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc21728: 48 00 0f 19 bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
ffc2172c: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
handle->dirty = false;
ffc21730: 9b df 00 44 stb r30,68(r31) <== NOT EXECUTED
ffc21734: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc21738: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
handle->bnum = 0;
ffc2173c: 93 df 00 48 stw r30,72(r31) <== NOT EXECUTED
handle->buffer = NULL;
ffc21740: 93 df 00 4c stw r30,76(r31) <== NOT EXECUTED
ffc21744: 83 61 00 0c lwz r27,12(r1) <== NOT EXECUTED
ffc21748: 83 81 00 10 lwz r28,16(r1) <== NOT EXECUTED
ffc2174c: 83 a1 00 14 lwz r29,20(r1) <== NOT EXECUTED
ffc21750: 83 c1 00 18 lwz r30,24(r1) <== NOT EXECUTED
ffc21754: 83 e1 00 1c lwz r31,28(r1) <== NOT EXECUTED
ffc21758: 38 21 00 20 addi r1,r1,32 <== NOT EXECUTED
ffc2175c: 4e 80 00 20 blr <== NOT EXECUTED
ffc22048 <rtems_rfs_block_map_shrink>:
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
ffc22048: 94 21 ff b8 stwu r1,-72(r1)
ffc2204c: 7c 08 02 a6 mflr r0
ffc22050: 93 c1 00 40 stw r30,64(r1)
ffc22054: 7c 7e 1b 78 mr r30,r3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
ffc22058: 38 60 00 00 li r3,0
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
ffc2205c: 93 e1 00 44 stw r31,68(r1)
ffc22060: 7c 9f 23 78 mr r31,r4
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
ffc22064: 38 80 40 00 li r4,16384
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
ffc22068: 93 a1 00 3c stw r29,60(r1)
ffc2206c: 7c bd 2b 78 mr r29,r5
ffc22070: 90 01 00 4c stw r0,76(r1)
ffc22074: 92 61 00 14 stw r19,20(r1)
ffc22078: 92 81 00 18 stw r20,24(r1)
ffc2207c: 92 a1 00 1c stw r21,28(r1)
ffc22080: 92 c1 00 20 stw r22,32(r1)
ffc22084: 92 e1 00 24 stw r23,36(r1)
ffc22088: 93 01 00 28 stw r24,40(r1)
ffc2208c: 93 21 00 2c stw r25,44(r1)
ffc22090: 93 41 00 30 stw r26,48(r1)
ffc22094: 93 61 00 34 stw r27,52(r1)
ffc22098: 93 81 00 38 stw r28,56(r1)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
ffc2209c: 4b ff 58 cd bl ffc17968 <rtems_rfs_trace>
ffc220a0: 2f 83 00 00 cmpwi cr7,r3,0
ffc220a4: 40 9e 02 a0 bne- cr7,ffc22344 <rtems_rfs_block_map_shrink+0x2fc><== NEVER TAKEN
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
blocks, map->size.count);
if (map->size.count == 0)
ffc220a8: 81 3f 00 08 lwz r9,8(r31)
return 0;
ffc220ac: 38 60 00 00 li r3,0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
blocks, map->size.count);
if (map->size.count == 0)
ffc220b0: 2f 89 00 00 cmpwi cr7,r9,0
ffc220b4: 41 9e 01 c4 beq- cr7,ffc22278 <rtems_rfs_block_map_shrink+0x230><== ALWAYS TAKEN
ffc220b8: 7f 1d 48 40 cmplw cr6,r29,r9 <== NOT EXECUTED
ffc220bc: 93 a1 00 08 stw r29,8(r1) <== NOT EXECUTED
ffc220c0: 41 99 02 7c bgt- cr6,ffc2233c <rtems_rfs_block_map_shrink+0x2f4><== NOT EXECUTED
return 0;
if (blocks > map->size.count)
blocks = map->size.count;
while (blocks)
ffc220c4: 80 01 00 08 lwz r0,8(r1) <== NOT EXECUTED
ffc220c8: 2f 00 00 00 cmpwi cr6,r0,0 <== NOT EXECUTED
ffc220cc: 41 9a 02 a4 beq- cr6,ffc22370 <rtems_rfs_block_map_shrink+0x328><== NOT EXECUTED
/*
* We have less than RTEMS_RFS_INODE_BLOCKS so they are held in the
* inode.
*/
block_to_free = map->blocks[block];
map->blocks[block] = 0;
ffc220d0: 3b 80 00 00 li r28,0 <== NOT EXECUTED
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
ffc220d4: 3b 3f 00 44 addi r25,r31,68 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
ffc220d8: 3b 5f 00 38 addi r26,r31,56 <== NOT EXECUTED
int
rtems_rfs_block_map_free_all (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
return rtems_rfs_block_map_shrink (fs, map, map->size.count);
}
ffc220dc: 3a 9f 00 4c addi r20,r31,76 <== NOT EXECUTED
ffc220e0: 3a bf 00 40 addi r21,r31,64 <== NOT EXECUTED
if (rc > 0)
return rc;
map->size.count--;
map->size.offset = 0;
map->last_data_block = block_to_free;
map->dirty = true;
ffc220e4: 3b 60 00 01 li r27,1 <== NOT EXECUTED
ffc220e8: 48 00 00 58 b ffc22140 <rtems_rfs_block_map_shrink+0xf8><== NOT EXECUTED
{
/*
* We have less than RTEMS_RFS_INODE_BLOCKS so they are held in the
* inode.
*/
block_to_free = map->blocks[block];
ffc220ec: 39 29 00 07 addi r9,r9,7 <== NOT EXECUTED
ffc220f0: 55 29 10 3a rlwinm r9,r9,2,0,29 <== NOT EXECUTED
ffc220f4: 7d 3f 4a 14 add r9,r31,r9 <== NOT EXECUTED
ffc220f8: 83 a9 00 04 lwz r29,4(r9) <== NOT EXECUTED
map->blocks[block] = 0;
ffc220fc: 93 89 00 04 stw r28,4(r9) <== NOT EXECUTED
{
rc = EIO;
break;
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
ffc22100: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc22104: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc22108: 7f a5 eb 78 mr r5,r29 <== NOT EXECUTED
ffc2210c: 4b ff 1a 51 bl ffc13b5c <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
if (rc > 0)
ffc22110: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc22114: 41 81 01 64 bgt- ffc22278 <rtems_rfs_block_map_shrink+0x230><== NOT EXECUTED
return 0;
if (blocks > map->size.count)
blocks = map->size.count;
while (blocks)
ffc22118: 80 01 00 08 lwz r0,8(r1) <== NOT EXECUTED
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
if (rc > 0)
return rc;
map->size.count--;
ffc2211c: 81 3f 00 08 lwz r9,8(r31) <== NOT EXECUTED
return 0;
if (blocks > map->size.count)
blocks = map->size.count;
while (blocks)
ffc22120: 35 60 ff ff addic. r11,r0,-1 <== NOT EXECUTED
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
if (rc > 0)
return rc;
map->size.count--;
map->size.offset = 0;
ffc22124: 93 9f 00 0c stw r28,12(r31) <== NOT EXECUTED
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
if (rc > 0)
return rc;
map->size.count--;
ffc22128: 39 29 ff ff addi r9,r9,-1 <== NOT EXECUTED
ffc2212c: 91 3f 00 08 stw r9,8(r31) <== NOT EXECUTED
map->size.offset = 0;
map->last_data_block = block_to_free;
ffc22130: 93 bf 00 20 stw r29,32(r31) <== NOT EXECUTED
map->dirty = true;
ffc22134: 9b 7f 00 00 stb r27,0(r31) <== NOT EXECUTED
return 0;
if (blocks > map->size.count)
blocks = map->size.count;
while (blocks)
ffc22138: 91 61 00 08 stw r11,8(r1) <== NOT EXECUTED
ffc2213c: 41 82 02 24 beq- ffc22360 <rtems_rfs_block_map_shrink+0x318><== NOT EXECUTED
{
rtems_rfs_block_no block;
rtems_rfs_block_no block_to_free;
int rc;
block = map->size.count - 1;
ffc22140: 38 09 ff ff addi r0,r9,-1 <== NOT EXECUTED
if (block < RTEMS_RFS_INODE_BLOCKS)
ffc22144: 2b 80 00 04 cmplwi cr7,r0,4 <== NOT EXECUTED
ffc22148: 40 bd ff a4 ble- cr7,ffc220ec <rtems_rfs_block_map_shrink+0xa4><== NOT EXECUTED
* table of block numbers.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
ffc2214c: 83 be 00 30 lwz r29,48(r30) <== NOT EXECUTED
singly = block / fs->blocks_per_block;
if (block < fs->block_map_singly_blocks)
ffc22150: 81 7e 00 34 lwz r11,52(r30) <== NOT EXECUTED
* table of block numbers.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
ffc22154: 7f 00 eb 96 divwu r24,r0,r29 <== NOT EXECUTED
singly = block / fs->blocks_per_block;
if (block < fs->block_map_singly_blocks)
ffc22158: 7f 80 58 40 cmplw cr7,r0,r11 <== NOT EXECUTED
* table of block numbers.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
ffc2215c: 7e f8 e9 d6 mullw r23,r24,r29 <== NOT EXECUTED
ffc22160: 7e f7 00 50 subf r23,r23,r0 <== NOT EXECUTED
singly = block / fs->blocks_per_block;
if (block < fs->block_map_singly_blocks)
ffc22164: 41 9c 01 58 blt- cr7,ffc222bc <rtems_rfs_block_map_shrink+0x274><== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
singly, direct);
if (rc)
return rc;
}
else if (block < fs->block_map_doubly_blocks)
ffc22168: 81 7e 00 38 lwz r11,56(r30) <== NOT EXECUTED
ffc2216c: 7f 80 58 40 cmplw cr7,r0,r11 <== NOT EXECUTED
ffc22170: 40 9c 01 f0 bge- cr7,ffc22360 <rtems_rfs_block_map_shrink+0x318><== NOT EXECUTED
* value is still valid for doubly indirect tables.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
ffc22174: 7e d8 eb 96 divwu r22,r24,r29 <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
ffc22178: 39 36 00 08 addi r9,r22,8 <== NOT EXECUTED
ffc2217c: 55 29 10 3a rlwinm r9,r9,2,0,29 <== NOT EXECUTED
ffc22180: 7d 3f 4a 14 add r9,r31,r9 <== NOT EXECUTED
ffc22184: 80 a9 00 04 lwz r5,4(r9) <== NOT EXECUTED
ffc22188: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc2218c: 7f 24 cb 78 mr r4,r25 <== NOT EXECUTED
ffc22190: 38 c0 00 01 li r6,1 <== NOT EXECUTED
ffc22194: 48 00 06 c1 bl ffc22854 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
ffc22198: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc2219c: 41 81 00 dc bgt- ffc22278 <rtems_rfs_block_map_shrink+0x230><== NOT EXECUTED
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
doubly_singly = singly % fs->blocks_per_block;
ffc221a0: 7f b6 e9 d6 mullw r29,r22,r29 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
map->blocks[doubly], true);
if (rc > 0)
return rc;
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
ffc221a4: 81 3f 00 4c lwz r9,76(r31) <== NOT EXECUTED
ffc221a8: 81 69 00 24 lwz r11,36(r9) <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
ffc221ac: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
doubly_singly = singly % fs->blocks_per_block;
ffc221b0: 7f 1d c0 50 subf r24,r29,r24 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
map->blocks[doubly], true);
if (rc > 0)
return rc;
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
ffc221b4: 57 00 10 3a rlwinm r0,r24,2,0,29 <== NOT EXECUTED
ffc221b8: 7d 2b 02 14 add r9,r11,r0 <== NOT EXECUTED
ffc221bc: 7e 6b 00 ae lbzx r19,r11,r0 <== NOT EXECUTED
ffc221c0: 89 49 00 03 lbz r10,3(r9) <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
ffc221c4: 7f 44 d3 78 mr r4,r26 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
map->blocks[doubly], true);
if (rc > 0)
return rc;
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
ffc221c8: 89 69 00 01 lbz r11,1(r9) <== NOT EXECUTED
ffc221cc: 56 73 c0 0e rlwinm r19,r19,24,0,7 <== NOT EXECUTED
ffc221d0: 88 09 00 02 lbz r0,2(r9) <== NOT EXECUTED
ffc221d4: 7d 53 9b 78 or r19,r10,r19 <== NOT EXECUTED
ffc221d8: 55 69 80 1e rlwinm r9,r11,16,0,15 <== NOT EXECUTED
ffc221dc: 7e 73 4b 78 or r19,r19,r9 <== NOT EXECUTED
ffc221e0: 54 00 40 2e rlwinm r0,r0,8,0,23 <== NOT EXECUTED
ffc221e4: 7e 73 03 78 or r19,r19,r0 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
ffc221e8: 7e 65 9b 78 mr r5,r19 <== NOT EXECUTED
ffc221ec: 38 c0 00 01 li r6,1 <== NOT EXECUTED
ffc221f0: 48 00 06 65 bl ffc22854 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
singly, true);
if (rc > 0)
ffc221f4: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc221f8: 41 81 00 80 bgt- ffc22278 <rtems_rfs_block_map_shrink+0x230><== NOT EXECUTED
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
ffc221fc: 81 3f 00 40 lwz r9,64(r31) <== NOT EXECUTED
ffc22200: 56 e0 10 3a rlwinm r0,r23,2,0,29 <== NOT EXECUTED
direct);
if (direct == 0)
ffc22204: 2f 97 00 00 cmpwi cr7,r23,0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
singly, true);
if (rc > 0)
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
ffc22208: 81 69 00 24 lwz r11,36(r9) <== NOT EXECUTED
ffc2220c: 7d 2b 02 14 add r9,r11,r0 <== NOT EXECUTED
ffc22210: 7f ab 00 ae lbzx r29,r11,r0 <== NOT EXECUTED
ffc22214: 89 49 00 03 lbz r10,3(r9) <== NOT EXECUTED
ffc22218: 89 69 00 01 lbz r11,1(r9) <== NOT EXECUTED
ffc2221c: 57 bd c0 0e rlwinm r29,r29,24,0,7 <== NOT EXECUTED
ffc22220: 88 09 00 02 lbz r0,2(r9) <== NOT EXECUTED
ffc22224: 7d 5d eb 78 or r29,r10,r29 <== NOT EXECUTED
ffc22228: 55 69 80 1e rlwinm r9,r11,16,0,15 <== NOT EXECUTED
ffc2222c: 7f bd 4b 78 or r29,r29,r9 <== NOT EXECUTED
ffc22230: 54 00 40 2e rlwinm r0,r0,8,0,23 <== NOT EXECUTED
ffc22234: 7f bd 03 78 or r29,r29,r0 <== NOT EXECUTED
direct);
if (direct == 0)
ffc22238: 40 9e fe c8 bne+ cr7,ffc22100 <rtems_rfs_block_map_shrink+0xb8><== NOT EXECUTED
{
rc = rtems_rfs_group_bitmap_free (fs, false, singly);
ffc2223c: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc22240: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc22244: 7e 65 9b 78 mr r5,r19 <== NOT EXECUTED
ffc22248: 4b ff 19 15 bl ffc13b5c <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
if (rc > 0)
ffc2224c: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc22250: 41 81 00 28 bgt- ffc22278 <rtems_rfs_block_map_shrink+0x230><== NOT EXECUTED
return rc;
map->last_map_block = singly;
ffc22254: 92 7f 00 1c stw r19,28(r31) <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
ffc22258: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc2225c: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc22260: 7e 85 a3 78 mr r5,r20 <== NOT EXECUTED
ffc22264: 7e c6 b3 78 mr r6,r22 <== NOT EXECUTED
ffc22268: 7f 07 c3 78 mr r7,r24 <== NOT EXECUTED
ffc2226c: 4b ff f0 65 bl ffc212d0 <rtems_rfs_block_map_indirect_shrink.isra.12><== NOT EXECUTED
doubly, doubly_singly);
if (rc)
ffc22270: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc22274: 41 82 fe 8c beq+ ffc22100 <rtems_rfs_block_map_shrink+0xb8><== NOT EXECUTED
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
return 0;
}
ffc22278: 80 01 00 4c lwz r0,76(r1)
ffc2227c: 82 61 00 14 lwz r19,20(r1)
ffc22280: 7c 08 03 a6 mtlr r0
ffc22284: 82 81 00 18 lwz r20,24(r1)
ffc22288: 82 a1 00 1c lwz r21,28(r1)
ffc2228c: 82 c1 00 20 lwz r22,32(r1)
ffc22290: 82 e1 00 24 lwz r23,36(r1)
ffc22294: 83 01 00 28 lwz r24,40(r1)
ffc22298: 83 21 00 2c lwz r25,44(r1)
ffc2229c: 83 41 00 30 lwz r26,48(r1)
ffc222a0: 83 61 00 34 lwz r27,52(r1)
ffc222a4: 83 81 00 38 lwz r28,56(r1)
ffc222a8: 83 a1 00 3c lwz r29,60(r1)
ffc222ac: 83 c1 00 40 lwz r30,64(r1)
ffc222b0: 83 e1 00 44 lwz r31,68(r1)
ffc222b4: 38 21 00 48 addi r1,r1,72
ffc222b8: 4e 80 00 20 blr
{
/*
* Request the indirect block and then obtain the block number from the
* indirect block.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
ffc222bc: 39 38 00 08 addi r9,r24,8 <== NOT EXECUTED
ffc222c0: 55 29 10 3a rlwinm r9,r9,2,0,29 <== NOT EXECUTED
ffc222c4: 7d 3f 4a 14 add r9,r31,r9 <== NOT EXECUTED
ffc222c8: 80 a9 00 04 lwz r5,4(r9) <== NOT EXECUTED
ffc222cc: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc222d0: 7f 44 d3 78 mr r4,r26 <== NOT EXECUTED
ffc222d4: 38 c0 00 01 li r6,1 <== NOT EXECUTED
ffc222d8: 48 00 05 7d bl ffc22854 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
map->blocks[singly], true);
if (rc > 0)
ffc222dc: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc222e0: 41 a1 ff 98 bgt- ffc22278 <rtems_rfs_block_map_shrink+0x230><== NOT EXECUTED
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
ffc222e4: 81 3f 00 40 lwz r9,64(r31) <== NOT EXECUTED
ffc222e8: 56 e0 10 3a rlwinm r0,r23,2,0,29 <== NOT EXECUTED
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
ffc222ec: 7f 06 c3 78 mr r6,r24 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
map->blocks[singly], true);
if (rc > 0)
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
ffc222f0: 81 29 00 24 lwz r9,36(r9) <== NOT EXECUTED
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
ffc222f4: 7e e7 bb 78 mr r7,r23 <== NOT EXECUTED
ffc222f8: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
map->blocks[singly], true);
if (rc > 0)
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
ffc222fc: 7e c9 00 ee lbzux r22,r9,r0 <== NOT EXECUTED
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
ffc22300: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc22304: 7e a5 ab 78 mr r5,r21 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
map->blocks[singly], true);
if (rc > 0)
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
ffc22308: 8a e9 00 01 lbz r23,1(r9) <== NOT EXECUTED
ffc2230c: 8b 09 00 02 lbz r24,2(r9) <== NOT EXECUTED
ffc22310: 8b a9 00 03 lbz r29,3(r9) <== NOT EXECUTED
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
ffc22314: 4b ff ef bd bl ffc212d0 <rtems_rfs_block_map_indirect_shrink.isra.12><== NOT EXECUTED
singly, direct);
if (rc)
ffc22318: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc2231c: 40 a2 ff 5c bne- ffc22278 <rtems_rfs_block_map_shrink+0x230><== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
map->blocks[singly], true);
if (rc > 0)
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
ffc22320: 56 d6 c0 0e rlwinm r22,r22,24,0,7 <== NOT EXECUTED
ffc22324: 7f bd b3 78 or r29,r29,r22 <== NOT EXECUTED
ffc22328: 56 f7 80 1e rlwinm r23,r23,16,0,15 <== NOT EXECUTED
ffc2232c: 7f bd bb 78 or r29,r29,r23 <== NOT EXECUTED
ffc22330: 57 18 40 2e rlwinm r24,r24,8,0,23 <== NOT EXECUTED
ffc22334: 7f bd c3 78 or r29,r29,r24 <== NOT EXECUTED
ffc22338: 4b ff fd c8 b ffc22100 <rtems_rfs_block_map_shrink+0xb8><== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
blocks, map->size.count);
if (map->size.count == 0)
ffc2233c: 91 21 00 08 stw r9,8(r1) <== NOT EXECUTED
ffc22340: 4b ff fd 84 b ffc220c4 <rtems_rfs_block_map_shrink+0x7c><== NOT EXECUTED
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
ffc22344: 80 bf 00 08 lwz r5,8(r31) <== NOT EXECUTED
ffc22348: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc2234c: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc22350: 38 63 c8 08 addi r3,r3,-14328 <== NOT EXECUTED
ffc22354: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc22358: 48 00 89 ed bl ffc2ad44 <printf> <== NOT EXECUTED
ffc2235c: 4b ff fd 4c b ffc220a8 <rtems_rfs_block_map_shrink+0x60><== NOT EXECUTED
map->last_data_block = block_to_free;
map->dirty = true;
blocks--;
}
if (map->size.count == 0)
ffc22360: 2f 89 00 00 cmpwi cr7,r9,0 <== NOT EXECUTED
ffc22364: 40 9e 00 0c bne- cr7,ffc22370 <rtems_rfs_block_map_shrink+0x328><== NOT EXECUTED
{
map->last_map_block = 0;
ffc22368: 91 3f 00 1c stw r9,28(r31) <== NOT EXECUTED
map->last_data_block = 0;
ffc2236c: 91 3f 00 20 stw r9,32(r31) <== NOT EXECUTED
}
/*
* Keep the position inside the map.
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
ffc22370: 80 1f 00 10 lwz r0,16(r31) <== NOT EXECUTED
ffc22374: 2f 00 00 00 cmpwi cr6,r0,0 <== NOT EXECUTED
ffc22378: 40 9a 00 30 bne- cr6,ffc223a8 <rtems_rfs_block_map_shrink+0x360><== NOT EXECUTED
ffc2237c: 7f 89 00 40 cmplw cr7,r9,r0 <== NOT EXECUTED
ffc22380: 40 9d 00 2c ble- cr7,ffc223ac <rtems_rfs_block_map_shrink+0x364><== NOT EXECUTED
ffc22384: 39 69 ff ff addi r11,r9,-1 <== NOT EXECUTED
ffc22388: 7f 80 58 00 cmpw cr7,r0,r11 <== NOT EXECUTED
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
return 0;
ffc2238c: 38 60 00 00 li r3,0 <== NOT EXECUTED
}
/*
* Keep the position inside the map.
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
ffc22390: 40 9e fe e8 bne+ cr7,ffc22278 <rtems_rfs_block_map_shrink+0x230><== NOT EXECUTED
ffc22394: 80 1f 00 0c lwz r0,12(r31) <== NOT EXECUTED
ffc22398: 81 7f 00 14 lwz r11,20(r31) <== NOT EXECUTED
ffc2239c: 7f 8b 00 40 cmplw cr7,r11,r0 <== NOT EXECUTED
ffc223a0: 41 bd 00 10 bgt+ cr7,ffc223b0 <rtems_rfs_block_map_shrink+0x368><== NOT EXECUTED
ffc223a4: 4b ff fe d4 b ffc22278 <rtems_rfs_block_map_shrink+0x230><== NOT EXECUTED
ffc223a8: 40 be ff d4 bne- cr7,ffc2237c <rtems_rfs_block_map_shrink+0x334><== NOT EXECUTED
ffc223ac: 80 1f 00 0c lwz r0,12(r31) <== NOT EXECUTED
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
ffc223b0: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc223b4: 90 1f 00 14 stw r0,20(r31) <== NOT EXECUTED
ffc223b8: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc223bc: 91 3f 00 10 stw r9,16(r31) <== NOT EXECUTED
return 0;
ffc223c0: 38 60 00 00 li r3,0 <== NOT EXECUTED
/*
* Keep the position inside the map.
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
ffc223c4: 90 1f 00 18 stw r0,24(r31) <== NOT EXECUTED
ffc223c8: 41 be fe b0 beq- cr7,ffc22278 <rtems_rfs_block_map_shrink+0x230><== NOT EXECUTED
ffc223cc: 39 29 ff ff addi r9,r9,-1 <== NOT EXECUTED
ffc223d0: 91 3f 00 10 stw r9,16(r31) <== NOT EXECUTED
ffc223d4: 4b ff fe a4 b ffc22278 <rtems_rfs_block_map_shrink+0x230><== NOT EXECUTED
ffc29890 <rtems_rfs_buffer_bdbuf_release>:
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
ffc29890: 94 21 ff e8 stwu r1,-24(r1)
ffc29894: 7d 80 00 26 mfcr r12
ffc29898: 7c 08 02 a6 mflr r0
ffc2989c: 93 c1 00 10 stw r30,16(r1)
ffc298a0: 7c 9e 23 78 mr r30,r4
rtems_status_code sc;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
ffc298a4: 38 80 00 40 li r4,64
}
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
ffc298a8: 93 e1 00 14 stw r31,20(r1)
ffc298ac: 7c 7f 1b 78 mr r31,r3
rtems_status_code sc;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
ffc298b0: 38 60 00 00 li r3,0
}
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
ffc298b4: 90 01 00 1c stw r0,28(r1)
ffc298b8: 2e 1e 00 00 cmpwi cr4,r30,0
ffc298bc: 91 81 00 0c stw r12,12(r1)
rtems_status_code sc;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
ffc298c0: 4b fe e0 a9 bl ffc17968 <rtems_rfs_trace>
ffc298c4: 2f 83 00 00 cmpwi cr7,r3,0
ffc298c8: 41 9e 00 28 beq- cr7,ffc298f0 <rtems_rfs_buffer_bdbuf_release+0x60><== ALWAYS TAKEN
printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
ffc298cc: 80 9f 00 3c lwz r4,60(r31) <== NOT EXECUTED
ffc298d0: 80 bf 00 20 lwz r5,32(r31) <== NOT EXECUTED
ffc298d4: 40 92 00 88 bne- cr4,ffc2995c <rtems_rfs_buffer_bdbuf_release+0xcc><== NOT EXECUTED
ffc298d8: 3c c0 ff c4 lis r6,-60 <== NOT EXECUTED
ffc298dc: 38 c6 bc 60 addi r6,r6,-17312 <== NOT EXECUTED
ffc298e0: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc298e4: 38 63 dd d8 addi r3,r3,-8744 <== NOT EXECUTED
ffc298e8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc298ec: 48 00 14 59 bl ffc2ad44 <printf> <== NOT EXECUTED
((intptr_t) buffer->user),
buffer->block, modified ? "(modified)" : "");
if (modified)
sc = rtems_bdbuf_release_modified (buffer);
ffc298f0: 7f e3 fb 78 mr r3,r31
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
((intptr_t) buffer->user),
buffer->block, modified ? "(modified)" : "");
if (modified)
ffc298f4: 41 92 00 34 beq- cr4,ffc29928 <rtems_rfs_buffer_bdbuf_release+0x98>
sc = rtems_bdbuf_release_modified (buffer);
ffc298f8: 4b ff 0d b5 bl ffc1a6ac <rtems_bdbuf_release_modified>
else
sc = rtems_bdbuf_release (buffer);
if (sc != RTEMS_SUCCESSFUL)
ffc298fc: 2f 83 00 00 cmpwi cr7,r3,0
#if RTEMS_RFS_BUFFER_ERRORS
printf ("rtems-rfs: buffer-release: bdbuf-%s: %s(%d)\n",
modified ? "modified" : "not-modified",
rtems_status_text (sc), sc);
#endif
rc = EIO;
ffc29900: 38 60 00 05 li r3,5
if (modified)
sc = rtems_bdbuf_release_modified (buffer);
else
sc = rtems_bdbuf_release (buffer);
if (sc != RTEMS_SUCCESSFUL)
ffc29904: 41 9e 00 34 beq- cr7,ffc29938 <rtems_rfs_buffer_bdbuf_release+0xa8><== ALWAYS TAKEN
#endif
rc = EIO;
}
return rc;
}
ffc29908: 80 01 00 1c lwz r0,28(r1) <== NOT EXECUTED
ffc2990c: 81 81 00 0c lwz r12,12(r1) <== NOT EXECUTED
ffc29910: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc29914: 83 c1 00 10 lwz r30,16(r1) <== NOT EXECUTED
ffc29918: 83 e1 00 14 lwz r31,20(r1) <== NOT EXECUTED
ffc2991c: 7d 80 81 20 mtcrf 8,r12 <== NOT EXECUTED
ffc29920: 38 21 00 18 addi r1,r1,24 <== NOT EXECUTED
ffc29924: 4e 80 00 20 blr <== NOT EXECUTED
buffer->block, modified ? "(modified)" : "");
if (modified)
sc = rtems_bdbuf_release_modified (buffer);
else
sc = rtems_bdbuf_release (buffer);
ffc29928: 4b ff 0c 7d bl ffc1a5a4 <rtems_bdbuf_release>
if (sc != RTEMS_SUCCESSFUL)
ffc2992c: 2f 83 00 00 cmpwi cr7,r3,0
#if RTEMS_RFS_BUFFER_ERRORS
printf ("rtems-rfs: buffer-release: bdbuf-%s: %s(%d)\n",
modified ? "modified" : "not-modified",
rtems_status_text (sc), sc);
#endif
rc = EIO;
ffc29930: 38 60 00 05 li r3,5
if (modified)
sc = rtems_bdbuf_release_modified (buffer);
else
sc = rtems_bdbuf_release (buffer);
if (sc != RTEMS_SUCCESSFUL)
ffc29934: 40 9e ff d4 bne+ cr7,ffc29908 <rtems_rfs_buffer_bdbuf_release+0x78><== NEVER TAKEN
#endif
rc = EIO;
}
return rc;
}
ffc29938: 80 01 00 1c lwz r0,28(r1)
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
rtems_status_code sc;
int rc = 0;
ffc2993c: 38 60 00 00 li r3,0
#endif
rc = EIO;
}
return rc;
}
ffc29940: 81 81 00 0c lwz r12,12(r1)
ffc29944: 7c 08 03 a6 mtlr r0
ffc29948: 83 c1 00 10 lwz r30,16(r1)
ffc2994c: 83 e1 00 14 lwz r31,20(r1)
ffc29950: 7d 80 81 20 mtcrf 8,r12
ffc29954: 38 21 00 18 addi r1,r1,24
ffc29958: 4e 80 00 20 blr
{
rtems_status_code sc;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
ffc2995c: 3c c0 ff c4 lis r6,-60 <== NOT EXECUTED
ffc29960: 38 c6 dd cc addi r6,r6,-8756 <== NOT EXECUTED
ffc29964: 4b ff ff 7c b ffc298e0 <rtems_rfs_buffer_bdbuf_release+0x50><== NOT EXECUTED
ffc29828 <rtems_rfs_buffer_bdbuf_request>:
int
rtems_rfs_buffer_bdbuf_request (rtems_rfs_file_system* fs,
rtems_rfs_buffer_block block,
bool read,
rtems_rfs_buffer** buffer)
{
ffc29828: 94 21 ff f8 stwu r1,-8(r1)
ffc2982c: 7c 08 02 a6 mflr r0
rtems_status_code sc;
int rc = 0;
if (read)
ffc29830: 2f 85 00 00 cmpwi cr7,r5,0
int
rtems_rfs_buffer_bdbuf_request (rtems_rfs_file_system* fs,
rtems_rfs_buffer_block block,
bool read,
rtems_rfs_buffer** buffer)
{
ffc29834: 90 01 00 0c stw r0,12(r1)
ffc29838: 7c 85 23 78 mr r5,r4
rtems_status_code sc;
int rc = 0;
if (read)
sc = rtems_bdbuf_read (rtems_rfs_fs_device (fs), block, buffer);
ffc2983c: 81 23 00 0c lwz r9,12(r3)
ffc29840: 80 69 00 00 lwz r3,0(r9)
ffc29844: 80 89 00 04 lwz r4,4(r9)
rtems_rfs_buffer** buffer)
{
rtems_status_code sc;
int rc = 0;
if (read)
ffc29848: 41 9e 00 24 beq- cr7,ffc2986c <rtems_rfs_buffer_bdbuf_request+0x44>
sc = rtems_bdbuf_read (rtems_rfs_fs_device (fs), block, buffer);
ffc2984c: 4b ff 09 fd bl ffc1a248 <rtems_bdbuf_read>
else
sc = rtems_bdbuf_get (rtems_rfs_fs_device (fs), block, buffer);
if (sc != RTEMS_SUCCESSFUL)
ffc29850: 2f 83 00 00 cmpwi cr7,r3,0
{
#if RTEMS_RFS_BUFFER_ERRORS
printf ("rtems-rfs: buffer-bdbuf-request: block=%lu: bdbuf-%s: %d: %s\n",
block, read ? "read" : "get", sc, rtems_status_text (sc));
#endif
rc = EIO;
ffc29854: 38 60 00 05 li r3,5
if (read)
sc = rtems_bdbuf_read (rtems_rfs_fs_device (fs), block, buffer);
else
sc = rtems_bdbuf_get (rtems_rfs_fs_device (fs), block, buffer);
if (sc != RTEMS_SUCCESSFUL)
ffc29858: 41 9e 00 24 beq- cr7,ffc2987c <rtems_rfs_buffer_bdbuf_request+0x54><== ALWAYS TAKEN
#endif
rc = EIO;
}
return rc;
}
ffc2985c: 80 01 00 0c lwz r0,12(r1) <== NOT EXECUTED
ffc29860: 38 21 00 08 addi r1,r1,8 <== NOT EXECUTED
ffc29864: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc29868: 4e 80 00 20 blr <== NOT EXECUTED
int rc = 0;
if (read)
sc = rtems_bdbuf_read (rtems_rfs_fs_device (fs), block, buffer);
else
sc = rtems_bdbuf_get (rtems_rfs_fs_device (fs), block, buffer);
ffc2986c: 4b ff 08 b9 bl ffc1a124 <rtems_bdbuf_get>
if (sc != RTEMS_SUCCESSFUL)
ffc29870: 2f 83 00 00 cmpwi cr7,r3,0
{
#if RTEMS_RFS_BUFFER_ERRORS
printf ("rtems-rfs: buffer-bdbuf-request: block=%lu: bdbuf-%s: %d: %s\n",
block, read ? "read" : "get", sc, rtems_status_text (sc));
#endif
rc = EIO;
ffc29874: 38 60 00 05 li r3,5
if (read)
sc = rtems_bdbuf_read (rtems_rfs_fs_device (fs), block, buffer);
else
sc = rtems_bdbuf_get (rtems_rfs_fs_device (fs), block, buffer);
if (sc != RTEMS_SUCCESSFUL)
ffc29878: 40 9e ff e4 bne+ cr7,ffc2985c <rtems_rfs_buffer_bdbuf_request+0x34><== NEVER TAKEN
#endif
rc = EIO;
}
return rc;
}
ffc2987c: 80 01 00 0c lwz r0,12(r1)
rtems_rfs_buffer_block block,
bool read,
rtems_rfs_buffer** buffer)
{
rtems_status_code sc;
int rc = 0;
ffc29880: 38 60 00 00 li r3,0
#endif
rc = EIO;
}
return rc;
}
ffc29884: 38 21 00 08 addi r1,r1,8
ffc29888: 7c 08 03 a6 mtlr r0
ffc2988c: 4e 80 00 20 blr
ffc22fe4 <rtems_rfs_buffer_close>:
return 0;
}
int
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
ffc22fe4: 94 21 ff f0 stwu r1,-16(r1)
ffc22fe8: 7c 08 02 a6 mflr r0
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
ffc22fec: 38 80 00 10 li r4,16
return 0;
}
int
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
ffc22ff0: 93 e1 00 0c stw r31,12(r1)
ffc22ff4: 7c 7f 1b 78 mr r31,r3
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
ffc22ff8: 38 60 00 00 li r3,0
return 0;
}
int
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
ffc22ffc: 90 01 00 14 stw r0,20(r1)
ffc23000: 93 c1 00 08 stw r30,8(r1)
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
ffc23004: 4b ff 49 65 bl ffc17968 <rtems_rfs_trace>
ffc23008: 2f 83 00 00 cmpwi cr7,r3,0
ffc2300c: 40 9e 00 98 bne- cr7,ffc230a4 <rtems_rfs_buffer_close+0xc0><== NEVER TAKEN
/*
* Change the block size to the media device size. It will release and sync
* all buffers.
*/
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs));
ffc23010: 81 3f 00 0c lwz r9,12(r31)
ffc23014: 7f e3 fb 78 mr r3,r31
ffc23018: 80 89 00 24 lwz r4,36(r9)
ffc2301c: 4b ff fe 75 bl ffc22e90 <rtems_rfs_buffer_setblksize>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
ffc23020: 7c 7e 1b 79 mr. r30,r3
ffc23024: 40 81 00 18 ble- ffc2303c <rtems_rfs_buffer_close+0x58> <== ALWAYS TAKEN
ffc23028: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc2302c: 38 80 00 10 li r4,16 <== NOT EXECUTED
ffc23030: 4b ff 49 39 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc23034: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc23038: 40 9e 00 28 bne- cr7,ffc23060 <rtems_rfs_buffer_close+0x7c><== NOT EXECUTED
printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rtems_disk_release (fs->disk);
ffc2303c: 80 7f 00 0c lwz r3,12(r31)
ffc23040: 4b fe 40 85 bl ffc070c4 <rtems_disk_release>
rc, strerror (rc));
}
#endif
return rc;
}
ffc23044: 80 01 00 14 lwz r0,20(r1)
ffc23048: 7f c3 f3 78 mr r3,r30
ffc2304c: 83 e1 00 0c lwz r31,12(r1)
ffc23050: 7c 08 03 a6 mtlr r0
ffc23054: 83 c1 00 08 lwz r30,8(r1)
ffc23058: 38 21 00 10 addi r1,r1,16
ffc2305c: 4e 80 00 20 blr
* all buffers.
*/
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs));
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
ffc23060: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc23064: 48 00 8a 4d bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc23068: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc2306c: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc23070: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc23074: 38 63 cc a8 addi r3,r3,-13144 <== NOT EXECUTED
ffc23078: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc2307c: 48 00 7c c9 bl ffc2ad44 <printf> <== NOT EXECUTED
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rtems_disk_release (fs->disk);
ffc23080: 80 7f 00 0c lwz r3,12(r31) <== NOT EXECUTED
ffc23084: 4b fe 40 41 bl ffc070c4 <rtems_disk_release> <== NOT EXECUTED
rc, strerror (rc));
}
#endif
return rc;
}
ffc23088: 80 01 00 14 lwz r0,20(r1) <== NOT EXECUTED
ffc2308c: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc23090: 83 e1 00 0c lwz r31,12(r1) <== NOT EXECUTED
ffc23094: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc23098: 83 c1 00 08 lwz r30,8(r1) <== NOT EXECUTED
ffc2309c: 38 21 00 10 addi r1,r1,16 <== NOT EXECUTED
ffc230a0: 4e 80 00 20 blr <== NOT EXECUTED
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
printf ("rtems-rfs: buffer-close: closing\n");
ffc230a4: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc230a8: 38 63 cc 84 addi r3,r3,-13180 <== NOT EXECUTED
ffc230ac: 48 00 7e 4d bl ffc2aef8 <puts> <== NOT EXECUTED
ffc230b0: 4b ff ff 60 b ffc23010 <rtems_rfs_buffer_close+0x2c> <== NOT EXECUTED
ffc22640 <rtems_rfs_buffer_handle_release>:
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
ffc22640: 94 21 ff e8 stwu r1,-24(r1)
ffc22644: 7c 08 02 a6 mflr r0
ffc22648: 90 01 00 1c stw r0,28(r1)
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
ffc2264c: 80 04 00 08 lwz r0,8(r4)
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
ffc22650: 93 a1 00 0c stw r29,12(r1)
int rc = 0;
ffc22654: 3b a0 00 00 li r29,0
if (rtems_rfs_buffer_handle_has_block (handle))
ffc22658: 2f 80 00 00 cmpwi cr7,r0,0
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
ffc2265c: 93 c1 00 10 stw r30,16(r1)
ffc22660: 7c 7e 1b 78 mr r30,r3
ffc22664: 93 e1 00 14 stw r31,20(r1)
ffc22668: 7c 9f 23 78 mr r31,r4
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
ffc2266c: 41 9e 00 44 beq- cr7,ffc226b0 <rtems_rfs_buffer_handle_release+0x70>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
ffc22670: 38 60 00 00 li r3,0
ffc22674: 38 80 02 00 li r4,512
ffc22678: 4b ff 52 f1 bl ffc17968 <rtems_rfs_trace>
ffc2267c: 2f 83 00 00 cmpwi cr7,r3,0
ffc22680: 40 9e 00 50 bne- cr7,ffc226d0 <rtems_rfs_buffer_handle_release+0x90><== NEVER TAKEN
rtems_rfs_buffer_bnum (handle),
rtems_rfs_buffer_dirty (handle) ? "(dirty)" : "",
rtems_rfs_buffer_refs (handle),
rtems_rfs_buffer_refs (handle) == 0 ? "BAD REF COUNT" : "");
if (rtems_rfs_buffer_refs (handle) > 0)
ffc22684: 80 7f 00 08 lwz r3,8(r31)
ffc22688: 83 a3 00 38 lwz r29,56(r3)
ffc2268c: 2f 9d 00 00 cmpwi cr7,r29,0
ffc22690: 40 9d 00 10 ble- cr7,ffc226a0 <rtems_rfs_buffer_handle_release+0x60><== NEVER TAKEN
rtems_rfs_buffer_refs_down (handle);
ffc22694: 3b bd ff ff addi r29,r29,-1
ffc22698: 2f 9d 00 00 cmpwi cr7,r29,0
ffc2269c: 93 a3 00 38 stw r29,56(r3)
if (rtems_rfs_buffer_refs (handle) == 0)
ffc226a0: 41 9e 00 74 beq- cr7,ffc22714 <rtems_rfs_buffer_handle_release+0xd4>
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
int rc = 0;
ffc226a4: 3b a0 00 00 li r29,0
rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle));
fs->release_count++;
}
}
}
handle->buffer = NULL;
ffc226a8: 38 00 00 00 li r0,0
ffc226ac: 90 1f 00 08 stw r0,8(r31)
}
return rc;
}
ffc226b0: 80 01 00 1c lwz r0,28(r1)
ffc226b4: 7f a3 eb 78 mr r3,r29
ffc226b8: 83 c1 00 10 lwz r30,16(r1)
ffc226bc: 7c 08 03 a6 mtlr r0
ffc226c0: 83 a1 00 0c lwz r29,12(r1)
ffc226c4: 83 e1 00 14 lwz r31,20(r1)
ffc226c8: 38 21 00 18 addi r1,r1,24
ffc226cc: 4e 80 00 20 blr
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
ffc226d0: 88 1f 00 00 lbz r0,0(r31) <== NOT EXECUTED
ffc226d4: 80 9f 00 04 lwz r4,4(r31) <== NOT EXECUTED
ffc226d8: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc226dc: 40 9e 00 98 bne- cr7,ffc22774 <rtems_rfs_buffer_handle_release+0x134><== NOT EXECUTED
rtems_rfs_buffer_bnum (handle),
rtems_rfs_buffer_dirty (handle) ? "(dirty)" : "",
rtems_rfs_buffer_refs (handle),
rtems_rfs_buffer_refs (handle) == 0 ? "BAD REF COUNT" : "");
ffc226e0: 81 3f 00 08 lwz r9,8(r31) <== NOT EXECUTED
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
ffc226e4: 3c a0 ff c4 lis r5,-60 <== NOT EXECUTED
ffc226e8: 38 a5 bc 60 addi r5,r5,-17312 <== NOT EXECUTED
rtems_rfs_buffer_bnum (handle),
rtems_rfs_buffer_dirty (handle) ? "(dirty)" : "",
rtems_rfs_buffer_refs (handle),
rtems_rfs_buffer_refs (handle) == 0 ? "BAD REF COUNT" : "");
ffc226ec: 80 c9 00 38 lwz r6,56(r9) <== NOT EXECUTED
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
ffc226f0: 2f 86 00 00 cmpwi cr7,r6,0 <== NOT EXECUTED
ffc226f4: 40 9e 00 98 bne- cr7,ffc2278c <rtems_rfs_buffer_handle_release+0x14c><== NOT EXECUTED
ffc226f8: 3c e0 ff c4 lis r7,-60 <== NOT EXECUTED
ffc226fc: 38 e7 c8 cc addi r7,r7,-14132 <== NOT EXECUTED
ffc22700: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc22704: 38 63 c8 dc addi r3,r3,-14116 <== NOT EXECUTED
ffc22708: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc2270c: 48 00 86 39 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc22710: 4b ff ff 74 b ffc22684 <rtems_rfs_buffer_handle_release+0x44><== NOT EXECUTED
ffc22714: 4b fe c0 c5 bl ffc0e7d8 <_Chain_Extract>
if (rtems_rfs_buffer_refs (handle) == 0)
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
if (rtems_rfs_fs_no_local_cache (fs))
ffc22718: 80 1e 00 00 lwz r0,0(r30)
rtems_rfs_buffer_refs_down (handle);
if (rtems_rfs_buffer_refs (handle) == 0)
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
ffc2271c: 81 3e 00 4c lwz r9,76(r30)
if (rtems_rfs_fs_no_local_cache (fs))
ffc22720: 70 0b 00 02 andi. r11,r0,2
rtems_rfs_buffer_refs_down (handle);
if (rtems_rfs_buffer_refs (handle) == 0)
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
ffc22724: 38 09 ff ff addi r0,r9,-1
ffc22728: 90 1e 00 4c stw r0,76(r30)
if (rtems_rfs_fs_no_local_cache (fs))
ffc2272c: 40 82 00 6c bne- ffc22798 <rtems_rfs_buffer_handle_release+0x158>
* head.
*
* This code stops a large series of transactions causing all the
* buffers in the cache being held in queues of this file system.
*/
if ((fs->release_count +
ffc22730: 81 7e 00 6c lwz r11,108(r30)
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
int rc = 0;
ffc22734: 3b a0 00 00 li r29,0
* head.
*
* This code stops a large series of transactions causing all the
* buffers in the cache being held in queues of this file system.
*/
if ((fs->release_count +
ffc22738: 81 3e 00 5c lwz r9,92(r30)
ffc2273c: 80 1e 00 3c lwz r0,60(r30)
ffc22740: 7d 2b 4a 14 add r9,r11,r9
ffc22744: 7f 89 00 40 cmplw cr7,r9,r0
ffc22748: 40 9c 00 80 bge- cr7,ffc227c8 <rtems_rfs_buffer_handle_release+0x188><== NEVER TAKEN
}
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
}
if (rtems_rfs_buffer_dirty (handle))
ffc2274c: 88 1f 00 00 lbz r0,0(r31)
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
ffc22750: 80 9f 00 08 lwz r4,8(r31)
ffc22754: 2f 80 00 00 cmpwi cr7,r0,0
ffc22758: 41 9e 00 58 beq- cr7,ffc227b0 <rtems_rfs_buffer_handle_release+0x170>
ffc2275c: 38 7e 00 60 addi r3,r30,96
ffc22760: 4b fe c0 49 bl ffc0e7a8 <_Chain_Append>
{
rtems_chain_append (&fs->release_modified,
rtems_rfs_buffer_link (handle));
fs->release_modified_count++;
ffc22764: 81 3e 00 6c lwz r9,108(r30)
ffc22768: 38 09 00 01 addi r0,r9,1
ffc2276c: 90 1e 00 6c stw r0,108(r30)
ffc22770: 4b ff ff 38 b ffc226a8 <rtems_rfs_buffer_handle_release+0x68>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
rtems_rfs_buffer_bnum (handle),
rtems_rfs_buffer_dirty (handle) ? "(dirty)" : "",
rtems_rfs_buffer_refs (handle),
rtems_rfs_buffer_refs (handle) == 0 ? "BAD REF COUNT" : "");
ffc22774: 81 3f 00 08 lwz r9,8(r31) <== NOT EXECUTED
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
ffc22778: 3c a0 ff c4 lis r5,-60 <== NOT EXECUTED
ffc2277c: 38 a5 c8 c4 addi r5,r5,-14140 <== NOT EXECUTED
rtems_rfs_buffer_bnum (handle),
rtems_rfs_buffer_dirty (handle) ? "(dirty)" : "",
rtems_rfs_buffer_refs (handle),
rtems_rfs_buffer_refs (handle) == 0 ? "BAD REF COUNT" : "");
ffc22780: 80 c9 00 38 lwz r6,56(r9) <== NOT EXECUTED
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
ffc22784: 2f 86 00 00 cmpwi cr7,r6,0 <== NOT EXECUTED
ffc22788: 41 be ff 70 beq- cr7,ffc226f8 <rtems_rfs_buffer_handle_release+0xb8><== NOT EXECUTED
ffc2278c: 3c e0 ff c4 lis r7,-60 <== NOT EXECUTED
ffc22790: 38 e7 bc 60 addi r7,r7,-17312 <== NOT EXECUTED
ffc22794: 4b ff ff 6c b ffc22700 <rtems_rfs_buffer_handle_release+0xc0><== NOT EXECUTED
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
if (rtems_rfs_fs_no_local_cache (fs))
{
handle->buffer->user = (void*) 0;
ffc22798: 80 7f 00 08 lwz r3,8(r31)
rc = rtems_rfs_buffer_io_release (handle->buffer,
ffc2279c: 88 9f 00 00 lbz r4,0(r31)
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
if (rtems_rfs_fs_no_local_cache (fs))
{
handle->buffer->user = (void*) 0;
ffc227a0: 93 a3 00 3c stw r29,60(r3)
rc = rtems_rfs_buffer_io_release (handle->buffer,
ffc227a4: 48 00 70 ed bl ffc29890 <rtems_rfs_buffer_bdbuf_release>
ffc227a8: 7c 7d 1b 78 mr r29,r3
ffc227ac: 4b ff fe fc b ffc226a8 <rtems_rfs_buffer_handle_release+0x68>
ffc227b0: 38 7e 00 50 addi r3,r30,80
ffc227b4: 4b fe bf f5 bl ffc0e7a8 <_Chain_Append>
fs->release_modified_count++;
}
else
{
rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle));
fs->release_count++;
ffc227b8: 81 3e 00 5c lwz r9,92(r30)
ffc227bc: 38 09 00 01 addi r0,r9,1
ffc227c0: 90 1e 00 5c stw r0,92(r30)
ffc227c4: 4b ff fe e4 b ffc226a8 <rtems_rfs_buffer_handle_release+0x68>
fs->release_modified_count) >= fs->max_held_buffers)
{
rtems_rfs_buffer* buffer;
bool modified;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
ffc227c8: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc227cc: 38 80 02 00 li r4,512 <== NOT EXECUTED
ffc227d0: 4b ff 51 99 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc227d4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc227d8: 40 9e 00 5c bne- cr7,ffc22834 <rtems_rfs_buffer_handle_release+0x1f4><== NOT EXECUTED
printf ("rtems-rfs: buffer-release: local cache overflow:"
" %" PRIu32 "\n", fs->release_count + fs->release_modified_count);
if (fs->release_count > fs->release_modified_count)
ffc227dc: 81 3e 00 5c lwz r9,92(r30) <== NOT EXECUTED
ffc227e0: 80 1e 00 6c lwz r0,108(r30) <== NOT EXECUTED
ffc227e4: 7f 89 00 40 cmplw cr7,r9,r0 <== NOT EXECUTED
ffc227e8: 40 9d 00 30 ble- cr7,ffc22818 <rtems_rfs_buffer_handle_release+0x1d8><== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
ffc227ec: 38 7e 00 50 addi r3,r30,80 <== NOT EXECUTED
ffc227f0: 4b fe c0 11 bl ffc0e800 <_Chain_Get> <== NOT EXECUTED
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (&fs->release);
fs->release_count--;
ffc227f4: 81 3e 00 5c lwz r9,92(r30) <== NOT EXECUTED
modified = false;
ffc227f8: 38 80 00 00 li r4,0 <== NOT EXECUTED
" %" PRIu32 "\n", fs->release_count + fs->release_modified_count);
if (fs->release_count > fs->release_modified_count)
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (&fs->release);
fs->release_count--;
ffc227fc: 38 09 ff ff addi r0,r9,-1 <== NOT EXECUTED
ffc22800: 90 1e 00 5c stw r0,92(r30) <== NOT EXECUTED
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
modified = true;
}
buffer->user = (void*) 0;
ffc22804: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc22808: 90 03 00 3c stw r0,60(r3) <== NOT EXECUTED
rc = rtems_rfs_buffer_io_release (buffer, modified);
ffc2280c: 48 00 70 85 bl ffc29890 <rtems_rfs_buffer_bdbuf_release><== NOT EXECUTED
ffc22810: 7c 7d 1b 78 mr r29,r3 <== NOT EXECUTED
ffc22814: 4b ff ff 38 b ffc2274c <rtems_rfs_buffer_handle_release+0x10c><== NOT EXECUTED
ffc22818: 38 7e 00 60 addi r3,r30,96 <== NOT EXECUTED
ffc2281c: 4b fe bf e5 bl ffc0e800 <_Chain_Get> <== NOT EXECUTED
}
else
{
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
ffc22820: 81 3e 00 6c lwz r9,108(r30) <== NOT EXECUTED
modified = true;
ffc22824: 38 80 00 01 li r4,1 <== NOT EXECUTED
}
else
{
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
ffc22828: 38 09 ff ff addi r0,r9,-1 <== NOT EXECUTED
ffc2282c: 90 1e 00 6c stw r0,108(r30) <== NOT EXECUTED
ffc22830: 4b ff ff d4 b ffc22804 <rtems_rfs_buffer_handle_release+0x1c4><== NOT EXECUTED
{
rtems_rfs_buffer* buffer;
bool modified;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
printf ("rtems-rfs: buffer-release: local cache overflow:"
ffc22834: 80 9e 00 6c lwz r4,108(r30) <== NOT EXECUTED
ffc22838: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc2283c: 80 1e 00 5c lwz r0,92(r30) <== NOT EXECUTED
ffc22840: 38 63 c9 10 addi r3,r3,-14064 <== NOT EXECUTED
ffc22844: 7c 84 02 14 add r4,r4,r0 <== NOT EXECUTED
ffc22848: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc2284c: 48 00 84 f9 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc22850: 4b ff ff 8c b ffc227dc <rtems_rfs_buffer_handle_release+0x19c><== NOT EXECUTED
ffc22854 <rtems_rfs_buffer_handle_request>:
int
rtems_rfs_buffer_handle_request (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle,
rtems_rfs_buffer_block block,
bool read)
{
ffc22854: 94 21 ff e0 stwu r1,-32(r1)
ffc22858: 7c 08 02 a6 mflr r0
ffc2285c: 90 01 00 24 stw r0,36(r1)
/*
* If the handle has a buffer release it. This allows a handle to be reused
* without needing to close then open it again.
*/
if (rtems_rfs_buffer_handle_has_block (handle))
ffc22860: 80 04 00 08 lwz r0,8(r4)
int
rtems_rfs_buffer_handle_request (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle,
rtems_rfs_buffer_block block,
bool read)
{
ffc22864: 93 61 00 0c stw r27,12(r1)
ffc22868: 7c db 33 78 mr r27,r6
/*
* If the handle has a buffer release it. This allows a handle to be reused
* without needing to close then open it again.
*/
if (rtems_rfs_buffer_handle_has_block (handle))
ffc2286c: 2f 80 00 00 cmpwi cr7,r0,0
int
rtems_rfs_buffer_handle_request (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle,
rtems_rfs_buffer_block block,
bool read)
{
ffc22870: 93 81 00 10 stw r28,16(r1)
ffc22874: 7c 7c 1b 78 mr r28,r3
ffc22878: 93 a1 00 14 stw r29,20(r1)
ffc2287c: 7c 9d 23 78 mr r29,r4
ffc22880: 93 e1 00 1c stw r31,28(r1)
ffc22884: 7c bf 2b 78 mr r31,r5
ffc22888: 93 c1 00 18 stw r30,24(r1)
/*
* If the handle has a buffer release it. This allows a handle to be reused
* without needing to close then open it again.
*/
if (rtems_rfs_buffer_handle_has_block (handle))
ffc2288c: 41 9e 00 7c beq- cr7,ffc22908 <rtems_rfs_buffer_handle_request+0xb4>
{
/*
* Treat block 0 as special to handle the loading of the super block.
*/
if (block && (rtems_rfs_buffer_bnum (handle) == block))
ffc22890: 2f 85 00 00 cmpwi cr7,r5,0
ffc22894: 41 9e 00 14 beq- cr7,ffc228a8 <rtems_rfs_buffer_handle_request+0x54><== NEVER TAKEN
ffc22898: 80 04 00 04 lwz r0,4(r4)
return 0;
ffc2289c: 3b c0 00 00 li r30,0
if (rtems_rfs_buffer_handle_has_block (handle))
{
/*
* Treat block 0 as special to handle the loading of the super block.
*/
if (block && (rtems_rfs_buffer_bnum (handle) == block))
ffc228a0: 7f 80 28 00 cmpw cr7,r0,r5
ffc228a4: 41 9e 00 2c beq- cr7,ffc228d0 <rtems_rfs_buffer_handle_request+0x7c>
return 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
ffc228a8: 38 60 00 00 li r3,0
ffc228ac: 38 80 01 00 li r4,256
ffc228b0: 4b ff 50 b9 bl ffc17968 <rtems_rfs_trace>
ffc228b4: 2f 83 00 00 cmpwi cr7,r3,0
ffc228b8: 40 9e 01 28 bne- cr7,ffc229e0 <rtems_rfs_buffer_handle_request+0x18c><== NEVER TAKEN
printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
rtems_rfs_buffer_bnum (handle));
rc = rtems_rfs_buffer_handle_release (fs, handle);
ffc228bc: 7f 83 e3 78 mr r3,r28
ffc228c0: 7f a4 eb 78 mr r4,r29
ffc228c4: 4b ff fd 7d bl ffc22640 <rtems_rfs_buffer_handle_release>
if (rc > 0)
ffc228c8: 7c 7e 1b 79 mr. r30,r3
ffc228cc: 40 81 00 2c ble- ffc228f8 <rtems_rfs_buffer_handle_request+0xa4><== ALWAYS TAKEN
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
block, read ? "read" : "get", handle->buffer->block,
handle->buffer->references);
return 0;
}
ffc228d0: 80 01 00 24 lwz r0,36(r1)
ffc228d4: 7f c3 f3 78 mr r3,r30
ffc228d8: 83 61 00 0c lwz r27,12(r1)
ffc228dc: 7c 08 03 a6 mtlr r0
ffc228e0: 83 81 00 10 lwz r28,16(r1)
ffc228e4: 83 a1 00 14 lwz r29,20(r1)
ffc228e8: 83 c1 00 18 lwz r30,24(r1)
ffc228ec: 83 e1 00 1c lwz r31,28(r1)
ffc228f0: 38 21 00 20 addi r1,r1,32
ffc228f4: 4e 80 00 20 blr
rtems_rfs_buffer_bnum (handle));
rc = rtems_rfs_buffer_handle_release (fs, handle);
if (rc > 0)
return rc;
handle->dirty = false;
ffc228f8: 38 00 00 00 li r0,0
ffc228fc: 98 1d 00 00 stb r0,0(r29)
handle->bnum = 0;
ffc22900: 38 00 00 00 li r0,0
ffc22904: 90 1d 00 04 stw r0,4(r29)
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
ffc22908: 38 60 00 00 li r3,0
ffc2290c: 38 80 01 00 li r4,256
ffc22910: 4b ff 50 59 bl ffc17968 <rtems_rfs_trace>
ffc22914: 2f 83 00 00 cmpwi cr7,r3,0
ffc22918: 40 9e 01 7c bne- cr7,ffc22a94 <rtems_rfs_buffer_handle_request+0x240><== NEVER TAKEN
* currently attached to a handle. If it is share the access. A buffer could
* be shared where different parts of the block have separate functions. An
* example is an inode block and the file system needs to handle 2 inodes in
* the same block at the same time.
*/
if (fs->buffers_count)
ffc2291c: 80 1c 00 4c lwz r0,76(r28)
ffc22920: 2f 80 00 00 cmpwi cr7,r0,0
ffc22924: 40 9e 01 1c bne- cr7,ffc22a40 <rtems_rfs_buffer_handle_request+0x1ec>
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: buffer shared: refs: %d\n",
ffc22928: 80 9d 00 08 lwz r4,8(r29)
/*
* If the buffer has not been found check the local cache of released
* buffers. There are release and released modified lists to preserve the
* state.
*/
if (!rtems_rfs_fs_no_local_cache (fs) &&
ffc2292c: 80 1c 00 00 lwz r0,0(r28)
ffc22930: 2f 84 00 00 cmpwi cr7,r4,0
ffc22934: 70 09 00 02 andi. r9,r0,2
ffc22938: 41 82 00 c0 beq- ffc229f8 <rtems_rfs_buffer_handle_request+0x1a4>
}
/*
* If not located we request the buffer from the I/O layer.
*/
if (!rtems_rfs_buffer_handle_has_block (handle))
ffc2293c: 41 9e 01 7c beq- cr7,ffc22ab8 <rtems_rfs_buffer_handle_request+0x264><== ALWAYS TAKEN
}
/*
* Increase the reference count of the buffer.
*/
rtems_rfs_buffer_refs_up (handle);
ffc22940: 81 24 00 38 lwz r9,56(r4)
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
ffc22944: 38 7c 00 40 addi r3,r28,64
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
block, read ? "read" : "get", handle->buffer->block,
handle->buffer->references);
return 0;
ffc22948: 3b c0 00 00 li r30,0
}
/*
* Increase the reference count of the buffer.
*/
rtems_rfs_buffer_refs_up (handle);
ffc2294c: 38 09 00 01 addi r0,r9,1
ffc22950: 90 04 00 38 stw r0,56(r4)
ffc22954: 4b fe be 55 bl ffc0e7a8 <_Chain_Append>
rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));
fs->buffers_count++;
ffc22958: 81 7c 00 4c lwz r11,76(r28)
handle->buffer->user = (void*) ((intptr_t) block);
ffc2295c: 81 3d 00 08 lwz r9,8(r29)
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
ffc22960: 38 60 00 00 li r3,0
/*
* Increase the reference count of the buffer.
*/
rtems_rfs_buffer_refs_up (handle);
rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));
fs->buffers_count++;
ffc22964: 38 0b 00 01 addi r0,r11,1
ffc22968: 90 1c 00 4c stw r0,76(r28)
handle->buffer->user = (void*) ((intptr_t) block);
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
ffc2296c: 38 80 01 00 li r4,256
*/
rtems_rfs_buffer_refs_up (handle);
rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));
fs->buffers_count++;
handle->buffer->user = (void*) ((intptr_t) block);
ffc22970: 93 e9 00 3c stw r31,60(r9)
handle->bnum = block;
ffc22974: 93 fd 00 04 stw r31,4(r29)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
ffc22978: 4b ff 4f f1 bl ffc17968 <rtems_rfs_trace>
ffc2297c: 2f 83 00 00 cmpwi cr7,r3,0
ffc22980: 41 be ff 50 beq- cr7,ffc228d0 <rtems_rfs_buffer_handle_request+0x7c><== ALWAYS TAKEN
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
ffc22984: 2f 9b 00 00 cmpwi cr7,r27,0 <== NOT EXECUTED
ffc22988: 41 9e 01 24 beq- cr7,ffc22aac <rtems_rfs_buffer_handle_request+0x258><== NOT EXECUTED
ffc2298c: 3c a0 ff c4 lis r5,-60 <== NOT EXECUTED
ffc22990: 38 a5 be 90 addi r5,r5,-16752 <== NOT EXECUTED
block, read ? "read" : "get", handle->buffer->block,
ffc22994: 81 3d 00 08 lwz r9,8(r29) <== NOT EXECUTED
handle->buffer->user = (void*) ((intptr_t) block);
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
ffc22998: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc2299c: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc229a0: 80 c9 00 20 lwz r6,32(r9) <== NOT EXECUTED
ffc229a4: 38 63 ca 14 addi r3,r3,-13804 <== NOT EXECUTED
ffc229a8: 80 e9 00 38 lwz r7,56(r9) <== NOT EXECUTED
block, read ? "read" : "get", handle->buffer->block,
handle->buffer->references);
return 0;
ffc229ac: 3b c0 00 00 li r30,0 <== NOT EXECUTED
handle->buffer->user = (void*) ((intptr_t) block);
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
ffc229b0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc229b4: 48 00 83 91 bl ffc2ad44 <printf> <== NOT EXECUTED
block, read ? "read" : "get", handle->buffer->block,
handle->buffer->references);
return 0;
}
ffc229b8: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
ffc229bc: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc229c0: 83 61 00 0c lwz r27,12(r1) <== NOT EXECUTED
ffc229c4: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc229c8: 83 81 00 10 lwz r28,16(r1) <== NOT EXECUTED
ffc229cc: 83 a1 00 14 lwz r29,20(r1) <== NOT EXECUTED
ffc229d0: 83 c1 00 18 lwz r30,24(r1) <== NOT EXECUTED
ffc229d4: 83 e1 00 1c lwz r31,28(r1) <== NOT EXECUTED
ffc229d8: 38 21 00 20 addi r1,r1,32 <== NOT EXECUTED
ffc229dc: 4e 80 00 20 blr <== NOT EXECUTED
*/
if (block && (rtems_rfs_buffer_bnum (handle) == block))
return 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
ffc229e0: 80 9d 00 04 lwz r4,4(r29) <== NOT EXECUTED
ffc229e4: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc229e8: 38 63 c9 4c addi r3,r3,-14004 <== NOT EXECUTED
ffc229ec: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc229f0: 48 00 83 55 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc229f4: 4b ff fe c8 b ffc228bc <rtems_rfs_buffer_handle_request+0x68><== NOT EXECUTED
/*
* If the buffer has not been found check the local cache of released
* buffers. There are release and released modified lists to preserve the
* state.
*/
if (!rtems_rfs_fs_no_local_cache (fs) &&
ffc229f8: 40 9e ff 48 bne+ cr7,ffc22940 <rtems_rfs_buffer_handle_request+0xec>
!rtems_rfs_buffer_handle_has_block (handle))
{
/*
* Check the local cache of released buffers.
*/
if (fs->release_count)
ffc229fc: 80 1c 00 5c lwz r0,92(r28)
ffc22a00: 2f 80 00 00 cmpwi cr7,r0,0
ffc22a04: 40 9e 01 30 bne- cr7,ffc22b34 <rtems_rfs_buffer_handle_request+0x2e0>
handle->buffer = rtems_rfs_scan_chain (&fs->release,
&fs->release_count,
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
ffc22a08: 80 1c 00 6c lwz r0,108(r28)
ffc22a0c: 2f 80 00 00 cmpwi cr7,r0,0
ffc22a10: 41 be 00 a8 beq+ cr7,ffc22ab8 <rtems_rfs_buffer_handle_request+0x264>
fs->release_modified_count)
{
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
ffc22a14: 38 9c 00 6c addi r4,r28,108
ffc22a18: 38 7c 00 60 addi r3,r28,96
ffc22a1c: 7f e5 fb 78 mr r5,r31
ffc22a20: 4b ff fa a5 bl ffc224c4 <rtems_rfs_scan_chain>
&fs->release_modified_count,
block);
/*
* If we found a buffer retain the dirty buffer state.
*/
if (rtems_rfs_buffer_handle_has_block (handle))
ffc22a24: 2f 83 00 00 cmpwi cr7,r3,0
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
fs->release_modified_count)
{
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
ffc22a28: 90 7d 00 08 stw r3,8(r29)
ffc22a2c: 7c 64 1b 78 mr r4,r3
&fs->release_modified_count,
block);
/*
* If we found a buffer retain the dirty buffer state.
*/
if (rtems_rfs_buffer_handle_has_block (handle))
ffc22a30: 41 9e 00 88 beq- cr7,ffc22ab8 <rtems_rfs_buffer_handle_request+0x264>
rtems_rfs_buffer_mark_dirty (handle);
ffc22a34: 38 00 00 01 li r0,1
ffc22a38: 98 1d 00 00 stb r0,0(r29)
ffc22a3c: 4b ff ff 04 b ffc22940 <rtems_rfs_buffer_handle_request+0xec>
if (fs->buffers_count)
{
/*
* Check the active buffer list for shared buffers.
*/
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
ffc22a40: 38 9c 00 4c addi r4,r28,76
ffc22a44: 38 7c 00 40 addi r3,r28,64
ffc22a48: 7f e5 fb 78 mr r5,r31
ffc22a4c: 4b ff fa 79 bl ffc224c4 <rtems_rfs_scan_chain>
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
ffc22a50: 38 80 00 00 li r4,0
ffc22a54: 2f 83 00 00 cmpwi cr7,r3,0
if (fs->buffers_count)
{
/*
* Check the active buffer list for shared buffers.
*/
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
ffc22a58: 90 7d 00 08 stw r3,8(r29)
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
ffc22a5c: 41 be fe d0 beq- cr7,ffc2292c <rtems_rfs_buffer_handle_request+0xd8>
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
ffc22a60: 38 60 00 00 li r3,0
ffc22a64: 38 80 01 00 li r4,256
ffc22a68: 4b ff 4f 01 bl ffc17968 <rtems_rfs_trace>
* Check the active buffer list for shared buffers.
*/
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
ffc22a6c: 2f 83 00 00 cmpwi cr7,r3,0
ffc22a70: 41 9e fe b8 beq+ cr7,ffc22928 <rtems_rfs_buffer_handle_request+0xd4><== ALWAYS TAKEN
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: buffer shared: refs: %d\n",
rtems_rfs_buffer_refs (handle) + 1);
ffc22a74: 81 3d 00 08 lwz r9,8(r29) <== NOT EXECUTED
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: buffer shared: refs: %d\n",
ffc22a78: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc22a7c: 38 63 c9 a8 addi r3,r3,-13912 <== NOT EXECUTED
ffc22a80: 80 89 00 38 lwz r4,56(r9) <== NOT EXECUTED
ffc22a84: 38 84 00 01 addi r4,r4,1 <== NOT EXECUTED
ffc22a88: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc22a8c: 48 00 82 b9 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc22a90: 4b ff fe 98 b ffc22928 <rtems_rfs_buffer_handle_request+0xd4><== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: block=%" PRIu32 "\n", block);
ffc22a94: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc22a98: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc22a9c: 38 63 c9 80 addi r3,r3,-13952 <== NOT EXECUTED
ffc22aa0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc22aa4: 48 00 82 a1 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc22aa8: 4b ff fe 74 b ffc2291c <rtems_rfs_buffer_handle_request+0xc8><== NOT EXECUTED
handle->buffer->user = (void*) ((intptr_t) block);
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
ffc22aac: 3c a0 ff c4 lis r5,-60 <== NOT EXECUTED
ffc22ab0: 38 a5 c9 48 addi r5,r5,-14008 <== NOT EXECUTED
ffc22ab4: 4b ff fe e0 b ffc22994 <rtems_rfs_buffer_handle_request+0x140><== NOT EXECUTED
/*
* If not located we request the buffer from the I/O layer.
*/
if (!rtems_rfs_buffer_handle_has_block (handle))
{
rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
ffc22ab8: 7f e4 fb 78 mr r4,r31
ffc22abc: 7f 83 e3 78 mr r3,r28
ffc22ac0: 7f 65 db 78 mr r5,r27
ffc22ac4: 38 dd 00 08 addi r6,r29,8
ffc22ac8: 48 00 6d 61 bl ffc29828 <rtems_rfs_buffer_bdbuf_request>
rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle));
ffc22acc: 80 9d 00 08 lwz r4,8(r29)
if (rc > 0)
ffc22ad0: 7c 7e 1b 79 mr. r30,r3
ffc22ad4: 38 00 00 00 li r0,0
ffc22ad8: 90 04 00 04 stw r0,4(r4)
ffc22adc: 90 04 00 00 stw r0,0(r4)
ffc22ae0: 40 a1 fe 60 ble- ffc22940 <rtems_rfs_buffer_handle_request+0xec><== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
ffc22ae4: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc22ae8: 38 80 01 00 li r4,256 <== NOT EXECUTED
ffc22aec: 4b ff 4e 7d bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc22af0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc22af4: 41 be fd dc beq- cr7,ffc228d0 <rtems_rfs_buffer_handle_request+0x7c><== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
ffc22af8: 2f 9b 00 00 cmpwi cr7,r27,0 <== NOT EXECUTED
ffc22afc: 40 9e 00 5c bne- cr7,ffc22b58 <rtems_rfs_buffer_handle_request+0x304><== NOT EXECUTED
ffc22b00: 3f a0 ff c4 lis r29,-60 <== NOT EXECUTED
ffc22b04: 3b bd c9 48 addi r29,r29,-14008 <== NOT EXECUTED
ffc22b08: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc22b0c: 48 00 8f a5 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc22b10: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc22b14: 7c 67 1b 78 mr r7,r3 <== NOT EXECUTED
ffc22b18: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc22b1c: 7f a5 eb 78 mr r5,r29 <== NOT EXECUTED
ffc22b20: 7f c6 f3 78 mr r6,r30 <== NOT EXECUTED
ffc22b24: 38 63 c9 dc addi r3,r3,-13860 <== NOT EXECUTED
ffc22b28: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc22b2c: 48 00 82 19 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc22b30: 4b ff fd a0 b ffc228d0 <rtems_rfs_buffer_handle_request+0x7c><== NOT EXECUTED
{
/*
* Check the local cache of released buffers.
*/
if (fs->release_count)
handle->buffer = rtems_rfs_scan_chain (&fs->release,
ffc22b34: 38 9c 00 5c addi r4,r28,92
ffc22b38: 38 7c 00 50 addi r3,r28,80
ffc22b3c: 7f e5 fb 78 mr r5,r31
ffc22b40: 4b ff f9 85 bl ffc224c4 <rtems_rfs_scan_chain>
&fs->release_count,
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
ffc22b44: 2f 83 00 00 cmpwi cr7,r3,0
{
/*
* Check the local cache of released buffers.
*/
if (fs->release_count)
handle->buffer = rtems_rfs_scan_chain (&fs->release,
ffc22b48: 90 7d 00 08 stw r3,8(r29)
ffc22b4c: 7c 64 1b 78 mr r4,r3
&fs->release_count,
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
ffc22b50: 40 9e fd f0 bne+ cr7,ffc22940 <rtems_rfs_buffer_handle_request+0xec>
ffc22b54: 4b ff fe b4 b ffc22a08 <rtems_rfs_buffer_handle_request+0x1b4>
rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle));
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
ffc22b58: 3f a0 ff c4 lis r29,-60 <== NOT EXECUTED
ffc22b5c: 3b bd be 90 addi r29,r29,-16752 <== NOT EXECUTED
ffc22b60: 4b ff ff a8 b ffc22b08 <rtems_rfs_buffer_handle_request+0x2b4><== NOT EXECUTED
ffc22b64 <rtems_rfs_buffer_open>:
return rc;
}
int
rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs)
{
ffc22b64: 94 21 ff 98 stwu r1,-104(r1)
ffc22b68: 7c 08 02 a6 mflr r0
ffc22b6c: 93 a1 00 5c stw r29,92(r1)
ffc22b70: 7c 9d 23 78 mr r29,r4
struct stat st;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
ffc22b74: 38 80 00 20 li r4,32
return rc;
}
int
rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs)
{
ffc22b78: 93 c1 00 60 stw r30,96(r1)
ffc22b7c: 7c 7e 1b 78 mr r30,r3
struct stat st;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
ffc22b80: 38 60 00 00 li r3,0
return rc;
}
int
rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs)
{
ffc22b84: 90 01 00 6c stw r0,108(r1)
ffc22b88: 93 e1 00 64 stw r31,100(r1)
struct stat st;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
ffc22b8c: 4b ff 4d dd bl ffc17968 <rtems_rfs_trace>
ffc22b90: 2f 83 00 00 cmpwi cr7,r3,0
ffc22b94: 40 9e 00 60 bne- cr7,ffc22bf4 <rtems_rfs_buffer_open+0x90><== NEVER TAKEN
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
if (stat (name, &st) < 0)
ffc22b98: 7f c3 f3 78 mr r3,r30
ffc22b9c: 38 81 00 08 addi r4,r1,8
ffc22ba0: 4b fe 76 cd bl ffc0a26c <stat>
ffc22ba4: 2f 83 00 00 cmpwi cr7,r3,0
ffc22ba8: 41 9c 00 74 blt- cr7,ffc22c1c <rtems_rfs_buffer_open+0xb8><== NEVER TAKEN
#if RTEMS_RFS_USE_LIBBLOCK
/*
* Is the device a block device ?
*/
if (!S_ISBLK (st.st_mode))
ffc22bac: 80 01 00 14 lwz r0,20(r1)
ffc22bb0: 54 00 04 26 rlwinm r0,r0,0,16,19
ffc22bb4: 2f 80 60 00 cmpwi cr7,r0,24576
ffc22bb8: 41 9e 00 a4 beq- cr7,ffc22c5c <rtems_rfs_buffer_open+0xf8><== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
ffc22bbc: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc22bc0: 38 80 00 08 li r4,8 <== NOT EXECUTED
ffc22bc4: 4b ff 4d a5 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name);
return EIO;
ffc22bc8: 3b e0 00 05 li r31,5 <== NOT EXECUTED
/*
* Is the device a block device ?
*/
if (!S_ISBLK (st.st_mode))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
ffc22bcc: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc22bd0: 40 9e 00 dc bne- cr7,ffc22cac <rtems_rfs_buffer_open+0x148><== NOT EXECUTED
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
rtems_rfs_fs_media_blocks (fs),
rtems_rfs_fs_media_block_size (fs));
return 0;
}
ffc22bd4: 80 01 00 6c lwz r0,108(r1)
ffc22bd8: 7f e3 fb 78 mr r3,r31
ffc22bdc: 83 a1 00 5c lwz r29,92(r1)
ffc22be0: 7c 08 03 a6 mtlr r0
ffc22be4: 83 c1 00 60 lwz r30,96(r1)
ffc22be8: 83 e1 00 64 lwz r31,100(r1)
ffc22bec: 38 21 00 68 addi r1,r1,104
ffc22bf0: 4e 80 00 20 blr
rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs)
{
struct stat st;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
ffc22bf4: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc22bf8: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc22bfc: 38 63 ca 50 addi r3,r3,-13744 <== NOT EXECUTED
ffc22c00: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc22c04: 48 00 81 41 bl ffc2ad44 <printf> <== NOT EXECUTED
if (stat (name, &st) < 0)
ffc22c08: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc22c0c: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc22c10: 4b fe 76 5d bl ffc0a26c <stat> <== NOT EXECUTED
ffc22c14: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc22c18: 40 9c ff 94 bge+ cr7,ffc22bac <rtems_rfs_buffer_open+0x48><== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
ffc22c1c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc22c20: 38 80 00 08 li r4,8 <== NOT EXECUTED
ffc22c24: 4b ff 4d 45 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
name, strerror (errno));
return ENOENT;
ffc22c28: 3b e0 00 02 li r31,2 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
if (stat (name, &st) < 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
ffc22c2c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc22c30: 41 9e ff a4 beq+ cr7,ffc22bd4 <rtems_rfs_buffer_open+0x70><== NOT EXECUTED
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
name, strerror (errno));
ffc22c34: 48 00 70 2d bl ffc29c60 <__errno> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
if (stat (name, &st) < 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
ffc22c38: 80 63 00 00 lwz r3,0(r3) <== NOT EXECUTED
ffc22c3c: 48 00 8e 75 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc22c40: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc22c44: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc22c48: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc22c4c: 38 63 ca 78 addi r3,r3,-13704 <== NOT EXECUTED
ffc22c50: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc22c54: 48 00 80 f1 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc22c58: 4b ff ff 7c b ffc22bd4 <rtems_rfs_buffer_open+0x70> <== NOT EXECUTED
}
/*
* Check that device is registred as a block device and lock it.
*/
fs->disk = rtems_disk_obtain (st.st_rdev);
ffc22c5c: 80 61 00 20 lwz r3,32(r1)
ffc22c60: 80 81 00 24 lwz r4,36(r1)
ffc22c64: 4b fe 43 ad bl ffc07010 <rtems_disk_obtain>
if (!fs->disk)
ffc22c68: 2f 83 00 00 cmpwi cr7,r3,0
}
/*
* Check that device is registred as a block device and lock it.
*/
fs->disk = rtems_disk_obtain (st.st_rdev);
ffc22c6c: 90 7d 00 0c stw r3,12(r29)
if (!fs->disk)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
ffc22c70: 38 60 00 00 li r3,0
/*
* Check that device is registred as a block device and lock it.
*/
fs->disk = rtems_disk_obtain (st.st_rdev);
if (!fs->disk)
ffc22c74: 41 9e 00 6c beq- cr7,ffc22ce0 <rtems_rfs_buffer_open+0x17c><== NEVER TAKEN
}
fs->media_size = st.st_size;
strcat (fs->name, name);
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
ffc22c78: 38 80 00 20 li r4,32
ffc22c7c: 4b ff 4c ed bl ffc17968 <rtems_rfs_trace>
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
rtems_rfs_fs_media_blocks (fs),
rtems_rfs_fs_media_block_size (fs));
return 0;
ffc22c80: 3b e0 00 00 li r31,0
}
fs->media_size = st.st_size;
strcat (fs->name, name);
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
ffc22c84: 2f 83 00 00 cmpwi cr7,r3,0
ffc22c88: 41 9e ff 4c beq+ cr7,ffc22bd4 <rtems_rfs_buffer_open+0x70><== ALWAYS TAKEN
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
rtems_rfs_fs_media_blocks (fs),
ffc22c8c: 81 3d 00 0c lwz r9,12(r29) <== NOT EXECUTED
fs->media_size = st.st_size;
strcat (fs->name, name);
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
ffc22c90: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc22c94: 38 63 cb 0c addi r3,r3,-13556 <== NOT EXECUTED
ffc22c98: 80 89 00 1c lwz r4,28(r9) <== NOT EXECUTED
ffc22c9c: 80 a9 00 24 lwz r5,36(r9) <== NOT EXECUTED
ffc22ca0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc22ca4: 48 00 80 a1 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc22ca8: 4b ff ff 2c b ffc22bd4 <rtems_rfs_buffer_open+0x70> <== NOT EXECUTED
* Is the device a block device ?
*/
if (!S_ISBLK (st.st_mode))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name);
ffc22cac: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc22cb0: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc22cb4: 38 63 ca a8 addi r3,r3,-13656 <== NOT EXECUTED
ffc22cb8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc22cbc: 48 00 80 89 bl ffc2ad44 <printf> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
rtems_rfs_fs_media_blocks (fs),
rtems_rfs_fs_media_block_size (fs));
return 0;
}
ffc22cc0: 80 01 00 6c lwz r0,108(r1) <== NOT EXECUTED
ffc22cc4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc22cc8: 83 a1 00 5c lwz r29,92(r1) <== NOT EXECUTED
ffc22ccc: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc22cd0: 83 c1 00 60 lwz r30,96(r1) <== NOT EXECUTED
ffc22cd4: 83 e1 00 64 lwz r31,100(r1) <== NOT EXECUTED
ffc22cd8: 38 21 00 68 addi r1,r1,104 <== NOT EXECUTED
ffc22cdc: 4e 80 00 20 blr <== NOT EXECUTED
* Check that device is registred as a block device and lock it.
*/
fs->disk = rtems_disk_obtain (st.st_rdev);
if (!fs->disk)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
ffc22ce0: 38 80 00 08 li r4,8 <== NOT EXECUTED
ffc22ce4: 4b ff 4c 85 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
return EIO;
ffc22ce8: 3b e0 00 05 li r31,5 <== NOT EXECUTED
* Check that device is registred as a block device and lock it.
*/
fs->disk = rtems_disk_obtain (st.st_rdev);
if (!fs->disk)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
ffc22cec: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc22cf0: 41 9e fe e4 beq+ cr7,ffc22bd4 <rtems_rfs_buffer_open+0x70><== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
ffc22cf4: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc22cf8: 38 63 ca dc addi r3,r3,-13604 <== NOT EXECUTED
ffc22cfc: 48 00 81 fd bl ffc2aef8 <puts> <== NOT EXECUTED
ffc22d00: 4b ff fe d4 b ffc22bd4 <rtems_rfs_buffer_open+0x70> <== NOT EXECUTED
ffc22e90 <rtems_rfs_buffer_setblksize>:
return result;
}
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
ffc22e90: 94 21 ff e8 stwu r1,-24(r1)
ffc22e94: 7c 08 02 a6 mflr r0
ffc22e98: 93 e1 00 14 stw r31,20(r1)
ffc22e9c: 7c 7f 1b 78 mr r31,r3
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
ffc22ea0: 38 60 00 00 li r3,0
return result;
}
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
ffc22ea4: 90 81 00 08 stw r4,8(r1)
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
ffc22ea8: 38 80 04 00 li r4,1024
return result;
}
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
ffc22eac: 90 01 00 1c stw r0,28(r1)
ffc22eb0: 93 c1 00 10 stw r30,16(r1)
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
ffc22eb4: 4b ff 4a b5 bl ffc17968 <rtems_rfs_trace>
ffc22eb8: 2f 83 00 00 cmpwi cr7,r3,0
ffc22ebc: 40 9e 00 88 bne- cr7,ffc22f44 <rtems_rfs_buffer_setblksize+0xb4><== NEVER TAKEN
printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size);
rc = rtems_rfs_buffers_release (fs);
ffc22ec0: 7f e3 fb 78 mr r3,r31
ffc22ec4: 4b ff ff 21 bl ffc22de4 <rtems_rfs_buffers_release>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
ffc22ec8: 7c 7e 1b 79 mr. r30,r3
ffc22ecc: 40 81 00 18 ble- ffc22ee4 <rtems_rfs_buffer_setblksize+0x54><== ALWAYS TAKEN
ffc22ed0: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc22ed4: 38 80 04 00 li r4,1024 <== NOT EXECUTED
ffc22ed8: 4b ff 4a 91 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc22edc: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc22ee0: 40 9e 00 e0 bne- cr7,ffc22fc0 <rtems_rfs_buffer_setblksize+0x130><== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
rc, strerror (rc));
rc = rtems_rfs_buffer_sync (fs);
ffc22ee4: 7f e3 fb 78 mr r3,r31
ffc22ee8: 4b ff fe 1d bl ffc22d04 <rtems_rfs_buffer_sync>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
ffc22eec: 7c 7e 1b 79 mr. r30,r3
ffc22ef0: 40 81 00 18 ble- ffc22f08 <rtems_rfs_buffer_setblksize+0x78><== ALWAYS TAKEN
ffc22ef4: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc22ef8: 38 80 04 00 li r4,1024 <== NOT EXECUTED
ffc22efc: 4b ff 4a 6d bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc22f00: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc22f04: 40 9e 00 58 bne- cr7,ffc22f5c <rtems_rfs_buffer_setblksize+0xcc><== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n",
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
ffc22f08: 80 7f 00 0c lwz r3,12(r31)
ffc22f0c: 3c 80 80 04 lis r4,-32764
ffc22f10: 60 84 42 04 ori r4,r4,16900
ffc22f14: 80 03 00 28 lwz r0,40(r3)
ffc22f18: 38 a1 00 08 addi r5,r1,8
ffc22f1c: 7c 09 03 a6 mtctr r0
ffc22f20: 4e 80 04 21 bctrl
if (rc < 0)
ffc22f24: 2c 03 00 00 cmpwi r3,0
ffc22f28: 41 80 00 78 blt- ffc22fa0 <rtems_rfs_buffer_setblksize+0x110><== NEVER TAKEN
rc = errno;
#endif
return rc;
}
ffc22f2c: 80 01 00 1c lwz r0,28(r1)
ffc22f30: 83 c1 00 10 lwz r30,16(r1)
ffc22f34: 7c 08 03 a6 mtlr r0
ffc22f38: 83 e1 00 14 lwz r31,20(r1)
ffc22f3c: 38 21 00 18 addi r1,r1,24
ffc22f40: 4e 80 00 20 blr
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size);
ffc22f44: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
ffc22f48: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc22f4c: 38 63 cb d8 addi r3,r3,-13352 <== NOT EXECUTED
ffc22f50: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc22f54: 48 00 7d f1 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc22f58: 4b ff ff 68 b ffc22ec0 <rtems_rfs_buffer_setblksize+0x30><== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
rc, strerror (rc));
rc = rtems_rfs_buffer_sync (fs);
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n",
ffc22f5c: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc22f60: 48 00 8b 51 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc22f64: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc22f68: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc22f6c: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc22f70: 38 63 cc 48 addi r3,r3,-13240 <== NOT EXECUTED
ffc22f74: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc22f78: 48 00 7d cd bl ffc2ad44 <printf> <== NOT EXECUTED
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
ffc22f7c: 80 7f 00 0c lwz r3,12(r31) <== NOT EXECUTED
ffc22f80: 3c 80 80 04 lis r4,-32764 <== NOT EXECUTED
ffc22f84: 80 03 00 28 lwz r0,40(r3) <== NOT EXECUTED
ffc22f88: 60 84 42 04 ori r4,r4,16900 <== NOT EXECUTED
ffc22f8c: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
ffc22f90: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc22f94: 4e 80 04 21 bctrl <== NOT EXECUTED
if (rc < 0)
ffc22f98: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc22f9c: 40 80 ff 90 bge+ ffc22f2c <rtems_rfs_buffer_setblksize+0x9c><== NOT EXECUTED
rc = errno;
ffc22fa0: 48 00 6c c1 bl ffc29c60 <__errno> <== NOT EXECUTED
#endif
return rc;
}
ffc22fa4: 80 01 00 1c lwz r0,28(r1) <== NOT EXECUTED
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
if (rc < 0)
rc = errno;
ffc22fa8: 80 63 00 00 lwz r3,0(r3) <== NOT EXECUTED
#endif
return rc;
}
ffc22fac: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc22fb0: 83 c1 00 10 lwz r30,16(r1) <== NOT EXECUTED
ffc22fb4: 83 e1 00 14 lwz r31,20(r1) <== NOT EXECUTED
ffc22fb8: 38 21 00 18 addi r1,r1,24 <== NOT EXECUTED
ffc22fbc: 4e 80 00 20 blr <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size);
rc = rtems_rfs_buffers_release (fs);
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
ffc22fc0: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc22fc4: 48 00 8a ed bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc22fc8: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc22fcc: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc22fd0: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc22fd4: 38 63 cc 08 addi r3,r3,-13304 <== NOT EXECUTED
ffc22fd8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc22fdc: 48 00 7d 69 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc22fe0: 4b ff ff 04 b ffc22ee4 <rtems_rfs_buffer_setblksize+0x54><== NOT EXECUTED
ffc22d04 <rtems_rfs_buffer_sync>:
return rc;
}
int
rtems_rfs_buffer_sync (rtems_rfs_file_system* fs)
{
ffc22d04: 94 21 ff e8 stwu r1,-24(r1)
ffc22d08: 7c 08 02 a6 mflr r0
int result = 0;
#if RTEMS_RFS_USE_LIBBLOCK
rtems_status_code sc;
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
ffc22d0c: 38 80 00 20 li r4,32
return rc;
}
int
rtems_rfs_buffer_sync (rtems_rfs_file_system* fs)
{
ffc22d10: 93 e1 00 14 stw r31,20(r1)
ffc22d14: 7c 7f 1b 78 mr r31,r3
int result = 0;
#if RTEMS_RFS_USE_LIBBLOCK
rtems_status_code sc;
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
ffc22d18: 38 60 00 00 li r3,0
return rc;
}
int
rtems_rfs_buffer_sync (rtems_rfs_file_system* fs)
{
ffc22d1c: 90 01 00 1c stw r0,28(r1)
ffc22d20: 93 a1 00 0c stw r29,12(r1)
ffc22d24: 93 c1 00 10 stw r30,16(r1)
int result = 0;
#if RTEMS_RFS_USE_LIBBLOCK
rtems_status_code sc;
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
ffc22d28: 4b ff 4c 41 bl ffc17968 <rtems_rfs_trace>
ffc22d2c: 2f 83 00 00 cmpwi cr7,r3,0
ffc22d30: 40 9e 00 a4 bne- cr7,ffc22dd4 <rtems_rfs_buffer_sync+0xd0><== NEVER TAKEN
/*
* @todo Split in the separate files for each type.
*/
#if RTEMS_RFS_USE_LIBBLOCK
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
ffc22d34: 81 3f 00 0c lwz r9,12(r31)
}
int
rtems_rfs_buffer_sync (rtems_rfs_file_system* fs)
{
int result = 0;
ffc22d38: 3b c0 00 00 li r30,0
/*
* @todo Split in the separate files for each type.
*/
#if RTEMS_RFS_USE_LIBBLOCK
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
ffc22d3c: 80 69 00 00 lwz r3,0(r9)
ffc22d40: 80 89 00 04 lwz r4,4(r9)
ffc22d44: 4b ff 7b 95 bl ffc1a8d8 <rtems_bdbuf_syncdev>
if (sc != RTEMS_SUCCESSFUL)
ffc22d48: 7c 7d 1b 79 mr. r29,r3
ffc22d4c: 40 82 00 2c bne- ffc22d78 <rtems_rfs_buffer_sync+0x74> <== NEVER TAKEN
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
rtems_status_text (sc));
result = EIO;
}
rtems_disk_release (fs->disk);
ffc22d50: 80 7f 00 0c lwz r3,12(r31)
ffc22d54: 4b fe 43 71 bl ffc070c4 <rtems_disk_release>
printf ("rtems-rfs: buffer-sync: file sync failed: %d: %s\n",
result, strerror (result));
}
#endif
return result;
}
ffc22d58: 80 01 00 1c lwz r0,28(r1)
ffc22d5c: 7f c3 f3 78 mr r3,r30
ffc22d60: 83 a1 00 0c lwz r29,12(r1)
ffc22d64: 7c 08 03 a6 mtlr r0
ffc22d68: 83 c1 00 10 lwz r30,16(r1)
ffc22d6c: 83 e1 00 14 lwz r31,20(r1)
ffc22d70: 38 21 00 18 addi r1,r1,24
ffc22d74: 4e 80 00 20 blr
*/
#if RTEMS_RFS_USE_LIBBLOCK
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
if (sc != RTEMS_SUCCESSFUL)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
ffc22d78: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc22d7c: 38 80 00 20 li r4,32 <== NOT EXECUTED
ffc22d80: 4b ff 4b e9 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
rtems_status_text (sc));
result = EIO;
ffc22d84: 3b c0 00 05 li r30,5 <== NOT EXECUTED
*/
#if RTEMS_RFS_USE_LIBBLOCK
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
if (sc != RTEMS_SUCCESSFUL)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
ffc22d88: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc22d8c: 41 9e ff c4 beq+ cr7,ffc22d50 <rtems_rfs_buffer_sync+0x4c><== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
ffc22d90: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc22d94: 4b ff 9a a9 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc22d98: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc22d9c: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc22da0: 38 63 cb 5c addi r3,r3,-13476 <== NOT EXECUTED
ffc22da4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc22da8: 48 00 7f 9d bl ffc2ad44 <printf> <== NOT EXECUTED
rtems_status_text (sc));
result = EIO;
}
rtems_disk_release (fs->disk);
ffc22dac: 80 7f 00 0c lwz r3,12(r31) <== NOT EXECUTED
ffc22db0: 4b fe 43 15 bl ffc070c4 <rtems_disk_release> <== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: file sync failed: %d: %s\n",
result, strerror (result));
}
#endif
return result;
}
ffc22db4: 80 01 00 1c lwz r0,28(r1) <== NOT EXECUTED
ffc22db8: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc22dbc: 83 a1 00 0c lwz r29,12(r1) <== NOT EXECUTED
ffc22dc0: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc22dc4: 83 c1 00 10 lwz r30,16(r1) <== NOT EXECUTED
ffc22dc8: 83 e1 00 14 lwz r31,20(r1) <== NOT EXECUTED
ffc22dcc: 38 21 00 18 addi r1,r1,24 <== NOT EXECUTED
ffc22dd0: 4e 80 00 20 blr <== NOT EXECUTED
#if RTEMS_RFS_USE_LIBBLOCK
rtems_status_code sc;
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
printf ("rtems-rfs: buffer-sync: syncing\n");
ffc22dd4: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc22dd8: 38 63 cb 3c addi r3,r3,-13508 <== NOT EXECUTED
ffc22ddc: 48 00 81 1d bl ffc2aef8 <puts> <== NOT EXECUTED
ffc22de0: 4b ff ff 54 b ffc22d34 <rtems_rfs_buffer_sync+0x30> <== NOT EXECUTED
ffc22de4 <rtems_rfs_buffers_release>:
return rrc;
}
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
ffc22de4: 94 21 ff f0 stwu r1,-16(r1)
ffc22de8: 7c 08 02 a6 mflr r0
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
ffc22dec: 38 80 00 40 li r4,64
return rrc;
}
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
ffc22df0: 93 e1 00 0c stw r31,12(r1)
ffc22df4: 7c 7f 1b 78 mr r31,r3
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
ffc22df8: 38 60 00 00 li r3,0
return rrc;
}
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
ffc22dfc: 90 01 00 14 stw r0,20(r1)
ffc22e00: 93 c1 00 08 stw r30,8(r1)
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
ffc22e04: 4b ff 4b 65 bl ffc17968 <rtems_rfs_trace>
ffc22e08: 2f 83 00 00 cmpwi cr7,r3,0
ffc22e0c: 40 9e 00 64 bne- cr7,ffc22e70 <rtems_rfs_buffers_release+0x8c><== NEVER TAKEN
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
"release:%" PRIu32 " release-modified:%" PRIu32 "\n",
fs->buffers_count, fs->release_count, fs->release_modified_count);
rc = rtems_rfs_release_chain (&fs->release,
ffc22e10: 38 9f 00 5c addi r4,r31,92
ffc22e14: 38 a0 00 00 li r5,0
ffc22e18: 38 7f 00 50 addi r3,r31,80
ffc22e1c: 4b ff f5 c5 bl ffc223e0 <rtems_rfs_release_chain>
&fs->release_count,
false);
if ((rc > 0) && (rrc == 0))
rrc = rc;
rc = rtems_rfs_release_chain (&fs->release_modified,
ffc22e20: 38 9f 00 6c addi r4,r31,108
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
"release:%" PRIu32 " release-modified:%" PRIu32 "\n",
fs->buffers_count, fs->release_count, fs->release_modified_count);
rc = rtems_rfs_release_chain (&fs->release,
ffc22e24: 7c 60 18 f8 not r0,r3
ffc22e28: 7c 7e 1b 78 mr r30,r3
ffc22e2c: 7c 00 fe 70 srawi r0,r0,31
&fs->release_count,
false);
if ((rc > 0) && (rrc == 0))
rrc = rc;
rc = rtems_rfs_release_chain (&fs->release_modified,
ffc22e30: 38 7f 00 60 addi r3,r31,96
ffc22e34: 38 a0 00 01 li r5,1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
"release:%" PRIu32 " release-modified:%" PRIu32 "\n",
fs->buffers_count, fs->release_count, fs->release_modified_count);
rc = rtems_rfs_release_chain (&fs->release,
ffc22e38: 7f de 00 38 and r30,r30,r0
&fs->release_count,
false);
if ((rc > 0) && (rrc == 0))
rrc = rc;
rc = rtems_rfs_release_chain (&fs->release_modified,
ffc22e3c: 4b ff f5 a5 bl ffc223e0 <rtems_rfs_release_chain>
&fs->release_modified_count,
true);
if ((rc > 0) && (rrc == 0))
ffc22e40: 2c 03 00 00 cmpwi r3,0
ffc22e44: 40 81 00 10 ble- ffc22e54 <rtems_rfs_buffers_release+0x70><== ALWAYS TAKEN
ffc22e48: 2f 9e 00 00 cmpwi cr7,r30,0 <== NOT EXECUTED
ffc22e4c: 40 9e 00 08 bne- cr7,ffc22e54 <rtems_rfs_buffers_release+0x70><== NOT EXECUTED
ffc22e50: 7c 7e 1b 78 mr r30,r3 <== NOT EXECUTED
rrc = rc;
return rrc;
}
ffc22e54: 80 01 00 14 lwz r0,20(r1)
ffc22e58: 7f c3 f3 78 mr r3,r30
ffc22e5c: 83 e1 00 0c lwz r31,12(r1)
ffc22e60: 7c 08 03 a6 mtlr r0
ffc22e64: 83 c1 00 08 lwz r30,8(r1)
ffc22e68: 38 21 00 10 addi r1,r1,16
ffc22e6c: 4e 80 00 20 blr
{
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
ffc22e70: 80 9f 00 4c lwz r4,76(r31) <== NOT EXECUTED
ffc22e74: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc22e78: 80 bf 00 5c lwz r5,92(r31) <== NOT EXECUTED
ffc22e7c: 38 63 cb 8c addi r3,r3,-13428 <== NOT EXECUTED
ffc22e80: 80 df 00 6c lwz r6,108(r31) <== NOT EXECUTED
ffc22e84: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc22e88: 48 00 7e bd bl ffc2ad44 <printf> <== NOT EXECUTED
ffc22e8c: 4b ff ff 84 b ffc22e10 <rtems_rfs_buffers_release+0x2c><== NOT EXECUTED
ffc23694 <rtems_rfs_dir_add_entry>:
rtems_rfs_dir_add_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
const char* name,
size_t length,
rtems_rfs_ino ino)
{
ffc23694: 94 21 ff 58 stwu r1,-168(r1)
ffc23698: 7c 08 02 a6 mflr r0
ffc2369c: 93 81 00 98 stw r28,152(r1)
ffc236a0: 7c 9c 23 78 mr r28,r4
rtems_rfs_block_map map;
rtems_rfs_block_pos bpos;
rtems_rfs_buffer_handle buffer;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
ffc236a4: 3c 80 20 00 lis r4,8192
rtems_rfs_dir_add_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
const char* name,
size_t length,
rtems_rfs_ino ino)
{
ffc236a8: 93 e1 00 a4 stw r31,164(r1)
ffc236ac: 7c 7f 1b 78 mr r31,r3
rtems_rfs_block_map map;
rtems_rfs_block_pos bpos;
rtems_rfs_buffer_handle buffer;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
ffc236b0: 38 60 00 00 li r3,0
rtems_rfs_dir_add_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
const char* name,
size_t length,
rtems_rfs_ino ino)
{
ffc236b4: 93 01 00 88 stw r24,136(r1)
ffc236b8: 7c f8 3b 78 mr r24,r7
ffc236bc: 93 a1 00 9c stw r29,156(r1)
ffc236c0: 7c bd 2b 78 mr r29,r5
ffc236c4: 93 c1 00 a0 stw r30,160(r1)
ffc236c8: 7c de 33 78 mr r30,r6
ffc236cc: 90 01 00 ac stw r0,172(r1)
ffc236d0: 92 a1 00 7c stw r21,124(r1)
ffc236d4: 92 c1 00 80 stw r22,128(r1)
ffc236d8: 92 e1 00 84 stw r23,132(r1)
ffc236dc: 93 21 00 8c stw r25,140(r1)
ffc236e0: 93 41 00 90 stw r26,144(r1)
ffc236e4: 93 61 00 94 stw r27,148(r1)
rtems_rfs_block_map map;
rtems_rfs_block_pos bpos;
rtems_rfs_buffer_handle buffer;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
ffc236e8: 4b ff 42 81 bl ffc17968 <rtems_rfs_trace>
ffc236ec: 2f 83 00 00 cmpwi cr7,r3,0
ffc236f0: 40 9e 02 78 bne- cr7,ffc23968 <rtems_rfs_dir_add_entry+0x2d4><== NEVER TAKEN
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (", len=%zd\n", length);
}
rc = rtems_rfs_block_map_open (fs, dir, &map);
ffc236f4: 7f e3 fb 78 mr r3,r31
ffc236f8: 7f 84 e3 78 mr r4,r28
ffc236fc: 38 a1 00 24 addi r5,r1,36
ffc23700: 4b ff de 59 bl ffc21558 <rtems_rfs_block_map_open>
if (rc > 0)
ffc23704: 7c 7b 1b 79 mr. r27,r3
ffc23708: 40 81 00 44 ble- ffc2374c <rtems_rfs_dir_add_entry+0xb8><== ALWAYS TAKEN
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
ffc2370c: 80 01 00 ac lwz r0,172(r1)
ffc23710: 7f 63 db 78 mr r3,r27
ffc23714: 82 a1 00 7c lwz r21,124(r1)
ffc23718: 7c 08 03 a6 mtlr r0
ffc2371c: 82 c1 00 80 lwz r22,128(r1)
ffc23720: 82 e1 00 84 lwz r23,132(r1)
ffc23724: 83 01 00 88 lwz r24,136(r1)
ffc23728: 83 21 00 8c lwz r25,140(r1)
ffc2372c: 83 41 00 90 lwz r26,144(r1)
ffc23730: 83 61 00 94 lwz r27,148(r1)
ffc23734: 83 81 00 98 lwz r28,152(r1)
ffc23738: 83 a1 00 9c lwz r29,156(r1)
ffc2373c: 83 c1 00 a0 lwz r30,160(r1)
ffc23740: 83 e1 00 a4 lwz r31,164(r1)
ffc23744: 38 21 00 a8 addi r1,r1,168
ffc23748: 4e 80 00 20 blr
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
handle->bnum = 0;
ffc2374c: 38 00 00 00 li r0,0
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc23750: 39 20 00 00 li r9,0
handle->bnum = 0;
ffc23754: 90 01 00 10 stw r0,16(r1)
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc23758: 3b 40 00 00 li r26,0
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc2375c: 99 21 00 0c stb r9,12(r1)
ffc23760: 63 5a ff ff ori r26,r26,65535
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
ffc23764: 3a fe 00 0a addi r23,r30,10
handle->bnum = 0;
handle->buffer = NULL;
ffc23768: 90 01 00 14 stw r0,20(r1)
* @param bpos A pointer to the block position.
*/
static inline void
rtems_rfs_block_set_bpos_zero (rtems_rfs_block_pos* bpos)
{
bpos->bno = 0;
ffc2376c: 90 01 00 18 stw r0,24(r1)
bpos->boff = 0;
ffc23770: 90 01 00 1c stw r0,28(r1)
bpos->block = 0;
ffc23774: 90 01 00 20 stw r0,32(r1)
/*
* Locate the first block. If an error the block will be 0. If the map is
* empty which happens when creating a directory and adding the first entry
* the seek will return ENXIO. In this case we need to grow the directory.
*/
rc = rtems_rfs_block_map_find (fs, &map, &bpos, &block);
ffc23778: 7f e3 fb 78 mr r3,r31
ffc2377c: 38 81 00 24 addi r4,r1,36
ffc23780: 38 a1 00 18 addi r5,r1,24
ffc23784: 38 c1 00 08 addi r6,r1,8
ffc23788: 4b ff e1 ed bl ffc21974 <rtems_rfs_block_map_find>
if (rc > 0)
ffc2378c: 7c 7b 1b 79 mr. r27,r3
ffc23790: 40 81 02 f0 ble- ffc23a80 <rtems_rfs_dir_add_entry+0x3ec>
{
if (rc != ENXIO)
ffc23794: 2f 9b 00 06 cmpwi cr7,r27,6
ffc23798: 40 9e 03 34 bne- cr7,ffc23acc <rtems_rfs_dir_add_entry+0x438><== NEVER TAKEN
}
/*
* We have reached the end of the directory so add a block.
*/
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
ffc2379c: 7f e3 fb 78 mr r3,r31
ffc237a0: 38 81 00 24 addi r4,r1,36
ffc237a4: 38 a0 00 01 li r5,1
ffc237a8: 38 c1 00 08 addi r6,r1,8
ffc237ac: 4b ff e4 75 bl ffc21c20 <rtems_rfs_block_map_grow>
if (rc > 0)
ffc237b0: 7c 7b 1b 79 mr. r27,r3
ffc237b4: 41 81 03 58 bgt- ffc23b0c <rtems_rfs_dir_add_entry+0x478><== NEVER TAKEN
"block map grow failed for ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (dir), rc, strerror (rc));
break;
}
read = false;
ffc237b8: 3b 20 00 00 li r25,0
}
bpos.bno++;
ffc237bc: 81 21 00 18 lwz r9,24(r1)
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
ffc237c0: 7f e3 fb 78 mr r3,r31
ffc237c4: 80 a1 00 08 lwz r5,8(r1)
ffc237c8: 38 81 00 0c addi r4,r1,12
}
read = false;
}
bpos.bno++;
ffc237cc: 38 09 00 01 addi r0,r9,1
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
ffc237d0: 7f 26 cb 78 mr r6,r25
}
read = false;
}
bpos.bno++;
ffc237d4: 90 01 00 18 stw r0,24(r1)
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
ffc237d8: 4b ff f0 7d bl ffc22854 <rtems_rfs_buffer_handle_request>
if (rc > 0)
ffc237dc: 7c 7b 1b 79 mr. r27,r3
ffc237e0: 41 81 02 a8 bgt- ffc23a88 <rtems_rfs_dir_add_entry+0x3f4><== NEVER TAKEN
break;
}
entry = rtems_rfs_buffer_data (&buffer);
if (!read)
ffc237e4: 2f 99 00 00 cmpwi cr7,r25,0
"block buffer req failed for ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (dir), rc, strerror (rc));
break;
}
entry = rtems_rfs_buffer_data (&buffer);
ffc237e8: 81 21 00 14 lwz r9,20(r1)
ffc237ec: 83 29 00 24 lwz r25,36(r9)
if (!read)
ffc237f0: 41 9e 01 cc beq- cr7,ffc239bc <rtems_rfs_dir_add_entry+0x328>
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
ffc237f4: 80 ff 00 08 lwz r7,8(r31)
ffc237f8: 35 47 ff f6 addic. r10,r7,-10
ffc237fc: 41 a2 ff 7c beq- ffc23778 <rtems_rfs_dir_add_entry+0xe4><== NEVER TAKEN
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
ffc23800: 8a b9 00 08 lbz r21,8(r25)
ffc23804: 88 19 00 09 lbz r0,9(r25)
ffc23808: 56 b5 40 2e rlwinm r21,r21,8,0,23
eino = rtems_rfs_dir_entry_ino (entry);
ffc2380c: 89 19 00 00 lbz r8,0(r25)
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
ffc23810: 7e b5 03 78 or r21,r21,r0
eino = rtems_rfs_dir_entry_ino (entry);
ffc23814: 89 79 00 02 lbz r11,2(r25)
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc23818: 7f 95 d0 00 cmpw cr7,r21,r26
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
ffc2381c: 88 19 00 01 lbz r0,1(r25)
ffc23820: 89 39 00 03 lbz r9,3(r25)
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc23824: 41 9e 01 ac beq- cr7,ffc239d0 <rtems_rfs_dir_add_entry+0x33c>
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
ffc23828: 55 16 c0 0e rlwinm r22,r8,24,0,7
ffc2382c: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc23830: 7e d6 5b 78 or r22,r22,r11
ffc23834: 7e d6 4b 78 or r22,r22,r9
ffc23838: 54 00 80 1e rlwinm r0,r0,16,0,15
ffc2383c: 7e d6 03 78 or r22,r22,r0
entry = rtems_rfs_buffer_data (&buffer);
if (!read)
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
offset = 0;
ffc23840: 3b 60 00 00 li r27,0
ffc23844: 48 00 00 70 b ffc238b4 <rtems_rfs_dir_add_entry+0x220>
}
break;
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
ffc23848: 80 1f 00 18 lwz r0,24(r31)
ffc2384c: 7f 95 00 40 cmplw cr7,r21,r0
ffc23850: 40 9c 00 74 bge- cr7,ffc238c4 <rtems_rfs_dir_add_entry+0x230><== NEVER TAKEN
ffc23854: 41 9a 00 70 beq- cr6,ffc238c4 <rtems_rfs_dir_add_entry+0x230><== NEVER TAKEN
ffc23858: 80 1f 00 10 lwz r0,16(r31)
ffc2385c: 7f 80 b0 40 cmplw cr7,r0,r22
ffc23860: 41 9c 00 64 blt- cr7,ffc238c4 <rtems_rfs_dir_add_entry+0x230><== NEVER TAKEN
rtems_rfs_block_map_close (fs, &map);
return EIO;
}
entry += elength;
offset += elength;
ffc23864: 7f 7b aa 14 add r27,r27,r21
if (!read)
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
ffc23868: 7f 9b 50 40 cmplw cr7,r27,r10
ffc2386c: 7f 68 db 78 mr r8,r27
ffc23870: 40 bc ff 08 bge- cr7,ffc23778 <rtems_rfs_dir_add_entry+0xe4><== NEVER TAKEN
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
ffc23874: 8a b9 00 08 lbz r21,8(r25)
ffc23878: 88 19 00 09 lbz r0,9(r25)
ffc2387c: 56 b5 40 2e rlwinm r21,r21,8,0,23
eino = rtems_rfs_dir_entry_ino (entry);
ffc23880: 8a d9 00 00 lbz r22,0(r25)
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
ffc23884: 7e b5 03 78 or r21,r21,r0
eino = rtems_rfs_dir_entry_ino (entry);
ffc23888: 89 79 00 01 lbz r11,1(r25)
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc2388c: 7f 95 d0 00 cmpw cr7,r21,r26
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
ffc23890: 89 39 00 03 lbz r9,3(r25)
ffc23894: 56 d6 c0 0e rlwinm r22,r22,24,0,7
ffc23898: 88 19 00 02 lbz r0,2(r25)
ffc2389c: 55 6b 80 1e rlwinm r11,r11,16,0,15
ffc238a0: 7e d6 5b 78 or r22,r22,r11
ffc238a4: 7e d6 4b 78 or r22,r22,r9
ffc238a8: 54 00 40 2e rlwinm r0,r0,8,0,23
ffc238ac: 7e d6 03 78 or r22,r22,r0
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc238b0: 41 9e 01 24 beq- cr7,ffc239d4 <rtems_rfs_dir_add_entry+0x340>
}
break;
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
ffc238b4: 2f 95 00 0a cmpwi cr7,r21,10
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return EIO;
}
entry += elength;
ffc238b8: 7f 39 aa 14 add r25,r25,r21
}
break;
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
ffc238bc: 2f 16 00 00 cmpwi cr6,r22,0
ffc238c0: 41 9d ff 88 bgt+ cr7,ffc23848 <rtems_rfs_dir_add_entry+0x1b4><== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
ffc238c4: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc238c8: 3c 80 20 00 lis r4,8192 <== NOT EXECUTED
ffc238cc: 4b ff 40 9d bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc238d0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc238d4: 41 be 00 24 beq+ cr7,ffc238f8 <rtems_rfs_dir_add_entry+0x264><== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
ffc238d8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc238dc: 80 9c 00 08 lwz r4,8(r28) <== NOT EXECUTED
ffc238e0: 38 63 d0 b0 addi r3,r3,-12112 <== NOT EXECUTED
ffc238e4: 7e a5 ab 78 mr r5,r21 <== NOT EXECUTED
ffc238e8: 7e c6 b3 78 mr r6,r22 <== NOT EXECUTED
ffc238ec: 7f 67 db 78 mr r7,r27 <== NOT EXECUTED
ffc238f0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc238f4: 48 00 74 51 bl ffc2ad44 <printf> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc238f8: 38 81 00 0c addi r4,r1,12 <== NOT EXECUTED
ffc238fc: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc23900: 4b ff ed 41 bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
ffc23904: 38 00 00 00 li r0,0 <== NOT EXECUTED
"bad length or ino for ino %" PRIu32 ": %u/%" PRId32 " @ %04x\n",
rtems_rfs_inode_ino (dir), elength, eino, offset);
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
ffc23908: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc2390c: 90 01 00 10 stw r0,16(r1) <== NOT EXECUTED
ffc23910: 38 81 00 24 addi r4,r1,36 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc23914: 39 20 00 00 li r9,0 <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
ffc23918: 90 01 00 14 stw r0,20(r1) <== NOT EXECUTED
return EIO;
ffc2391c: 3b 60 00 05 li r27,5 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc23920: 99 21 00 0c stb r9,12(r1) <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
printf ("rtems-rfs: dir-add-entry: "
"bad length or ino for ino %" PRIu32 ": %u/%" PRId32 " @ %04x\n",
rtems_rfs_inode_ino (dir), elength, eino, offset);
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
ffc23924: 4b ff de 3d bl ffc21760 <rtems_rfs_block_map_close> <== NOT EXECUTED
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
ffc23928: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc2392c: 80 01 00 ac lwz r0,172(r1) <== NOT EXECUTED
ffc23930: 82 a1 00 7c lwz r21,124(r1) <== NOT EXECUTED
ffc23934: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc23938: 82 c1 00 80 lwz r22,128(r1) <== NOT EXECUTED
ffc2393c: 82 e1 00 84 lwz r23,132(r1) <== NOT EXECUTED
ffc23940: 83 01 00 88 lwz r24,136(r1) <== NOT EXECUTED
ffc23944: 83 21 00 8c lwz r25,140(r1) <== NOT EXECUTED
ffc23948: 83 41 00 90 lwz r26,144(r1) <== NOT EXECUTED
ffc2394c: 83 61 00 94 lwz r27,148(r1) <== NOT EXECUTED
ffc23950: 83 81 00 98 lwz r28,152(r1) <== NOT EXECUTED
ffc23954: 83 a1 00 9c lwz r29,156(r1) <== NOT EXECUTED
ffc23958: 83 c1 00 a0 lwz r30,160(r1) <== NOT EXECUTED
ffc2395c: 83 e1 00 a4 lwz r31,164(r1) <== NOT EXECUTED
ffc23960: 38 21 00 a8 addi r1,r1,168 <== NOT EXECUTED
ffc23964: 4e 80 00 20 blr <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
{
int c;
printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",
ffc23968: 80 9c 00 08 lwz r4,8(r28) <== NOT EXECUTED
ffc2396c: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc23970: 38 63 cf a0 addi r3,r3,-12384 <== NOT EXECUTED
ffc23974: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc23978: 48 00 73 cd bl ffc2ad44 <printf> <== NOT EXECUTED
rtems_rfs_inode_ino (dir));
for (c = 0; c < length; c++)
ffc2397c: 2f 9e 00 00 cmpwi cr7,r30,0 <== NOT EXECUTED
ffc23980: 41 9e 00 24 beq- cr7,ffc239a4 <rtems_rfs_dir_add_entry+0x310><== NOT EXECUTED
ffc23984: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc23988: 3b 60 00 00 li r27,0 <== NOT EXECUTED
printf ("%c", name[c]);
ffc2398c: 7c 7d 00 ae lbzx r3,r29,r0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
{
int c;
printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",
rtems_rfs_inode_ino (dir));
for (c = 0; c < length; c++)
ffc23990: 3b 7b 00 01 addi r27,r27,1 <== NOT EXECUTED
printf ("%c", name[c]);
ffc23994: 48 00 74 6d bl ffc2ae00 <putchar> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
{
int c;
printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",
rtems_rfs_inode_ino (dir));
for (c = 0; c < length; c++)
ffc23998: 7f 9b f0 00 cmpw cr7,r27,r30 <== NOT EXECUTED
ffc2399c: 7f 60 db 78 mr r0,r27 <== NOT EXECUTED
ffc239a0: 40 9e ff ec bne+ cr7,ffc2398c <rtems_rfs_dir_add_entry+0x2f8><== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%zd\n", length);
ffc239a4: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc239a8: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc239ac: 38 63 cf cc addi r3,r3,-12340 <== NOT EXECUTED
ffc239b0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc239b4: 48 00 73 91 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc239b8: 4b ff fd 3c b ffc236f4 <rtems_rfs_dir_add_entry+0x60><== NOT EXECUTED
}
entry = rtems_rfs_buffer_data (&buffer);
if (!read)
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
ffc239bc: 80 bf 00 08 lwz r5,8(r31)
ffc239c0: 7f 23 cb 78 mr r3,r25
ffc239c4: 38 80 00 ff li r4,255
ffc239c8: 48 00 71 ed bl ffc2abb4 <memset>
ffc239cc: 4b ff fe 28 b ffc237f4 <rtems_rfs_dir_add_entry+0x160>
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
ffc239d0: 39 00 00 00 li r8,0
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
ffc239d4: 7d 08 38 50 subf r8,r8,r7
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
ffc239d8: 7f 97 40 40 cmplw cr7,r23,r8
ffc239dc: 40 9c fd 9c bge+ cr7,ffc23778 <rtems_rfs_dir_add_entry+0xe4><== NEVER TAKEN
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
ffc239e0: 7f c4 f3 78 mr r4,r30
ffc239e4: 7f a3 eb 78 mr r3,r29
ffc239e8: 48 00 5f 81 bl ffc29968 <rtems_rfs_dir_hash>
rtems_rfs_dir_set_entry_hash (entry, hash);
rtems_rfs_dir_set_entry_ino (entry, ino);
ffc239ec: 57 08 46 3e rlwinm r8,r24,8,24,31
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
rtems_rfs_dir_set_entry_hash (entry, hash);
ffc239f0: 54 66 84 3e rlwinm r6,r3,16,16,31
rtems_rfs_dir_set_entry_ino (entry, ino);
ffc239f4: 99 19 00 00 stb r8,0(r25)
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
rtems_rfs_dir_set_entry_hash (entry, hash);
ffc239f8: 54 67 c2 3e rlwinm r7,r3,24,8,31
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
ffc239fc: 7c 60 1b 78 mr r0,r3
rtems_rfs_dir_set_entry_hash (entry, hash);
ffc23a00: 98 d9 00 05 stb r6,5(r25)
rtems_rfs_dir_set_entry_ino (entry, ino);
ffc23a04: 57 0a 84 3e rlwinm r10,r24,16,16,31
ffc23a08: 57 0b c2 3e rlwinm r11,r24,24,8,31
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
rtems_rfs_dir_set_entry_hash (entry, hash);
ffc23a0c: 98 f9 00 06 stb r7,6(r25)
rtems_rfs_dir_set_entry_ino (entry, ino);
rtems_rfs_dir_set_entry_length (entry,
ffc23a10: 56 e9 c6 3e rlwinm r9,r23,24,24,31
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
rtems_rfs_dir_set_entry_hash (entry, hash);
ffc23a14: 54 65 46 3e rlwinm r5,r3,8,24,31
rtems_rfs_dir_set_entry_ino (entry, ino);
ffc23a18: 99 59 00 01 stb r10,1(r25)
rtems_rfs_dir_set_entry_length (entry,
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
ffc23a1c: 7f a4 eb 78 mr r4,r29
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
rtems_rfs_dir_set_entry_hash (entry, hash);
rtems_rfs_dir_set_entry_ino (entry, ino);
ffc23a20: 99 79 00 02 stb r11,2(r25)
rtems_rfs_dir_set_entry_length (entry,
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
ffc23a24: 38 79 00 0a addi r3,r25,10
rtems_rfs_buffer_mark_dirty (&buffer);
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return 0;
ffc23a28: 3b 60 00 00 li r27,0
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
rtems_rfs_dir_set_entry_hash (entry, hash);
rtems_rfs_dir_set_entry_ino (entry, ino);
rtems_rfs_dir_set_entry_length (entry,
ffc23a2c: 99 39 00 08 stb r9,8(r25)
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
rtems_rfs_dir_set_entry_hash (entry, hash);
ffc23a30: 98 b9 00 04 stb r5,4(r25)
rtems_rfs_dir_set_entry_ino (entry, ino);
rtems_rfs_dir_set_entry_length (entry,
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
ffc23a34: 7f c5 f3 78 mr r5,r30
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
rtems_rfs_dir_set_entry_hash (entry, hash);
ffc23a38: 98 19 00 07 stb r0,7(r25)
rtems_rfs_dir_set_entry_ino (entry, ino);
ffc23a3c: 9b 19 00 03 stb r24,3(r25)
rtems_rfs_dir_set_entry_length (entry,
ffc23a40: 9a f9 00 09 stb r23,9(r25)
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
ffc23a44: 48 00 6f 59 bl ffc2a99c <memcpy>
rtems_rfs_buffer_mark_dirty (&buffer);
ffc23a48: 38 00 00 01 li r0,1
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc23a4c: 38 81 00 0c addi r4,r1,12
ffc23a50: 98 01 00 0c stb r0,12(r1)
ffc23a54: 7f e3 fb 78 mr r3,r31
ffc23a58: 4b ff eb e9 bl ffc22640 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
handle->bnum = 0;
ffc23a5c: 38 00 00 00 li r0,0
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc23a60: 39 20 00 00 li r9,0
handle->bnum = 0;
ffc23a64: 90 01 00 10 stw r0,16(r1)
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
ffc23a68: 7f e3 fb 78 mr r3,r31
ffc23a6c: 38 81 00 24 addi r4,r1,36
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc23a70: 99 21 00 0c stb r9,12(r1)
handle->bnum = 0;
handle->buffer = NULL;
ffc23a74: 90 01 00 14 stw r0,20(r1)
ffc23a78: 4b ff dc e9 bl ffc21760 <rtems_rfs_block_map_close>
return 0;
ffc23a7c: 4b ff fc 90 b ffc2370c <rtems_rfs_dir_add_entry+0x78>
while (true)
{
rtems_rfs_block_no block;
uint8_t* entry;
int offset;
bool read = true;
ffc23a80: 3b 20 00 01 li r25,1
ffc23a84: 4b ff fd 38 b ffc237bc <rtems_rfs_dir_add_entry+0x128>
bpos.bno++;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
ffc23a88: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc23a8c: 3c 80 20 00 lis r4,8192 <== NOT EXECUTED
ffc23a90: 4b ff 3e d9 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc23a94: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc23a98: 40 9e 00 b4 bne- cr7,ffc23b4c <rtems_rfs_dir_add_entry+0x4b8><== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc23a9c: 38 81 00 0c addi r4,r1,12 <== NOT EXECUTED
ffc23aa0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc23aa4: 4b ff eb 9d bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
ffc23aa8: 38 00 00 00 li r0,0 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc23aac: 39 20 00 00 li r9,0 <== NOT EXECUTED
handle->bnum = 0;
ffc23ab0: 90 01 00 10 stw r0,16(r1) <== NOT EXECUTED
offset += elength;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
ffc23ab4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc23ab8: 38 81 00 24 addi r4,r1,36 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc23abc: 99 21 00 0c stb r9,12(r1) <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
ffc23ac0: 90 01 00 14 stw r0,20(r1) <== NOT EXECUTED
ffc23ac4: 4b ff dc 9d bl ffc21760 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
ffc23ac8: 4b ff fc 44 b ffc2370c <rtems_rfs_dir_add_entry+0x78><== NOT EXECUTED
rc = rtems_rfs_block_map_find (fs, &map, &bpos, &block);
if (rc > 0)
{
if (rc != ENXIO)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
ffc23acc: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc23ad0: 3c 80 20 00 lis r4,8192 <== NOT EXECUTED
ffc23ad4: 4b ff 3e 95 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc23ad8: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc23adc: 41 9e ff c0 beq+ cr7,ffc23a9c <rtems_rfs_dir_add_entry+0x408><== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
ffc23ae0: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc23ae4: 83 dc 00 08 lwz r30,8(r28) <== NOT EXECUTED
ffc23ae8: 48 00 7f c9 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc23aec: 7f 65 db 78 mr r5,r27 <== NOT EXECUTED
ffc23af0: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc23af4: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc23af8: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc23afc: 38 63 cf d8 addi r3,r3,-12328 <== NOT EXECUTED
ffc23b00: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc23b04: 48 00 72 41 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc23b08: 4b ff ff 94 b ffc23a9c <rtems_rfs_dir_add_entry+0x408><== NOT EXECUTED
* We have reached the end of the directory so add a block.
*/
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
ffc23b0c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc23b10: 3c 80 20 00 lis r4,8192 <== NOT EXECUTED
ffc23b14: 4b ff 3e 55 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc23b18: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc23b1c: 41 9e ff 80 beq+ cr7,ffc23a9c <rtems_rfs_dir_add_entry+0x408><== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
ffc23b20: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc23b24: 83 dc 00 08 lwz r30,8(r28) <== NOT EXECUTED
ffc23b28: 48 00 7f 89 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc23b2c: 7f 65 db 78 mr r5,r27 <== NOT EXECUTED
ffc23b30: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc23b34: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc23b38: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc23b3c: 38 63 d0 20 addi r3,r3,-12256 <== NOT EXECUTED
ffc23b40: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc23b44: 48 00 72 01 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc23b48: 4b ff ff 54 b ffc23a9c <rtems_rfs_dir_add_entry+0x408><== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
printf ("rtems-rfs: dir-add-entry: "
ffc23b4c: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc23b50: 83 dc 00 08 lwz r30,8(r28) <== NOT EXECUTED
ffc23b54: 48 00 7f 5d bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc23b58: 7f 65 db 78 mr r5,r27 <== NOT EXECUTED
ffc23b5c: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc23b60: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc23b64: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc23b68: 38 63 d0 68 addi r3,r3,-12184 <== NOT EXECUTED
ffc23b6c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc23b70: 48 00 71 d5 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc23b74: 4b ff ff 28 b ffc23a9c <rtems_rfs_dir_add_entry+0x408><== NOT EXECUTED
ffc23b78 <rtems_rfs_dir_del_entry>:
int
rtems_rfs_dir_del_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_ino ino,
uint32_t offset)
{
ffc23b78: 94 21 ff 68 stwu r1,-152(r1)
ffc23b7c: 7d 80 00 26 mfcr r12
ffc23b80: 7c 08 02 a6 mflr r0
ffc23b84: 93 a1 00 8c stw r29,140(r1)
ffc23b88: 7c 9d 23 78 mr r29,r4
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
bool search;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
ffc23b8c: 3c 80 40 00 lis r4,16384
int
rtems_rfs_dir_del_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_ino ino,
uint32_t offset)
{
ffc23b90: 93 e1 00 94 stw r31,148(r1)
ffc23b94: 7c 7f 1b 78 mr r31,r3
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
bool search;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
ffc23b98: 38 60 00 00 li r3,0
int
rtems_rfs_dir_del_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_ino ino,
uint32_t offset)
{
ffc23b9c: 93 61 00 84 stw r27,132(r1)
ffc23ba0: 7c bb 2b 78 mr r27,r5
ffc23ba4: 93 81 00 88 stw r28,136(r1)
ffc23ba8: 7c dc 33 78 mr r28,r6
ffc23bac: 90 01 00 9c stw r0,156(r1)
ffc23bb0: 92 c1 00 70 stw r22,112(r1)
ffc23bb4: 92 e1 00 74 stw r23,116(r1)
ffc23bb8: 93 01 00 78 stw r24,120(r1)
ffc23bbc: 93 21 00 7c stw r25,124(r1)
ffc23bc0: 93 41 00 80 stw r26,128(r1)
ffc23bc4: 93 c1 00 90 stw r30,144(r1)
ffc23bc8: 91 81 00 6c stw r12,108(r1)
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
bool search;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
ffc23bcc: 4b ff 3d 9d bl ffc17968 <rtems_rfs_trace>
ffc23bd0: 2f 83 00 00 cmpwi cr7,r3,0
ffc23bd4: 40 9e 00 60 bne- cr7,ffc23c34 <rtems_rfs_dir_del_entry+0xbc><== NEVER TAKEN
printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
rtems_rfs_inode_ino (dir), ino, offset);
rc = rtems_rfs_block_map_open (fs, dir, &map);
ffc23bd8: 7f e3 fb 78 mr r3,r31
ffc23bdc: 7f a4 eb 78 mr r4,r29
ffc23be0: 38 a1 00 18 addi r5,r1,24
ffc23be4: 4b ff d9 75 bl ffc21558 <rtems_rfs_block_map_open>
if (rc > 0)
ffc23be8: 7c 78 1b 79 mr. r24,r3
ffc23bec: 40 81 00 7c ble- ffc23c68 <rtems_rfs_dir_del_entry+0xf0><== ALWAYS TAKEN
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
ffc23bf0: 80 01 00 9c lwz r0,156(r1)
ffc23bf4: 7f 03 c3 78 mr r3,r24
ffc23bf8: 81 81 00 6c lwz r12,108(r1)
ffc23bfc: 7c 08 03 a6 mtlr r0
ffc23c00: 82 c1 00 70 lwz r22,112(r1)
ffc23c04: 82 e1 00 74 lwz r23,116(r1)
ffc23c08: 7d 80 81 20 mtcrf 8,r12
ffc23c0c: 83 01 00 78 lwz r24,120(r1)
ffc23c10: 83 21 00 7c lwz r25,124(r1)
ffc23c14: 83 41 00 80 lwz r26,128(r1)
ffc23c18: 83 61 00 84 lwz r27,132(r1)
ffc23c1c: 83 81 00 88 lwz r28,136(r1)
ffc23c20: 83 a1 00 8c lwz r29,140(r1)
ffc23c24: 83 c1 00 90 lwz r30,144(r1)
ffc23c28: 83 e1 00 94 lwz r31,148(r1)
ffc23c2c: 38 21 00 98 addi r1,r1,152
ffc23c30: 4e 80 00 20 blr
rtems_rfs_buffer_handle buffer;
bool search;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
ffc23c34: 80 9d 00 08 lwz r4,8(r29) <== NOT EXECUTED
ffc23c38: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc23c3c: 7f 65 db 78 mr r5,r27 <== NOT EXECUTED
ffc23c40: 7f 86 e3 78 mr r6,r28 <== NOT EXECUTED
ffc23c44: 38 63 d0 f8 addi r3,r3,-12040 <== NOT EXECUTED
ffc23c48: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc23c4c: 48 00 70 f9 bl ffc2ad44 <printf> <== NOT EXECUTED
rtems_rfs_inode_ino (dir), ino, offset);
rc = rtems_rfs_block_map_open (fs, dir, &map);
ffc23c50: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc23c54: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc23c58: 38 a1 00 18 addi r5,r1,24 <== NOT EXECUTED
ffc23c5c: 4b ff d8 fd bl ffc21558 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
ffc23c60: 7c 78 1b 79 mr. r24,r3 <== NOT EXECUTED
ffc23c64: 41 81 ff 8c bgt+ ffc23bf0 <rtems_rfs_dir_del_entry+0x78><== NOT EXECUTED
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
ffc23c68: 7f e3 fb 78 mr r3,r31
ffc23c6c: 38 81 00 18 addi r4,r1,24
ffc23c70: 38 a0 00 00 li r5,0
ffc23c74: 7f 86 e3 78 mr r6,r28
ffc23c78: 38 e1 00 08 addi r7,r1,8
ffc23c7c: 4b ff de a1 bl ffc21b1c <rtems_rfs_block_map_seek>
ffc23c80: 3b c0 00 00 li r30,0
if (rc > 0)
ffc23c84: 7c 78 1b 79 mr. r24,r3
ffc23c88: 40 81 00 20 ble- ffc23ca8 <rtems_rfs_dir_del_entry+0x130><== ALWAYS TAKEN
{
if (rc == ENXIO)
ffc23c8c: 2f 98 00 06 cmpwi cr7,r24,6 <== NOT EXECUTED
ffc23c90: 40 be 00 08 bne+ cr7,ffc23c98 <rtems_rfs_dir_del_entry+0x120><== NOT EXECUTED
rc = ENOENT;
ffc23c94: 3b 00 00 02 li r24,2 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
ffc23c98: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc23c9c: 38 81 00 18 addi r4,r1,24 <== NOT EXECUTED
ffc23ca0: 4b ff da c1 bl ffc21760 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
ffc23ca4: 4b ff ff 4c b ffc23bf0 <rtems_rfs_dir_del_entry+0x78><== NOT EXECUTED
}
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
ffc23ca8: 7f 80 00 34 cntlzw r0,r28
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc23cac: 9b c1 00 0c stb r30,12(r1)
ffc23cb0: 54 00 d9 7e rlwinm r0,r0,27,5,31
/*
* If we are searching start at the beginning of the block. If not searching
* skip to the offset in the block.
*/
if (search)
ffc23cb4: 2e 00 00 00 cmpwi cr4,r0,0
handle->bnum = 0;
ffc23cb8: 93 c1 00 10 stw r30,16(r1)
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc23cbc: 3a e0 00 00 li r23,0
handle->buffer = NULL;
ffc23cc0: 93 c1 00 14 stw r30,20(r1)
ffc23cc4: 62 f7 ff ff ori r23,r23,65535
while (rc == 0)
{
uint8_t* entry;
int eoffset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
ffc23cc8: 80 a1 00 08 lwz r5,8(r1)
ffc23ccc: 7f e3 fb 78 mr r3,r31
ffc23cd0: 38 81 00 0c addi r4,r1,12
ffc23cd4: 38 c0 00 01 li r6,1
ffc23cd8: 4b ff eb 7d bl ffc22854 <rtems_rfs_buffer_handle_request>
if (rc > 0)
ffc23cdc: 7c 78 1b 79 mr. r24,r3
ffc23ce0: 41 81 03 10 bgt- ffc23ff0 <rtems_rfs_dir_del_entry+0x478><== NEVER TAKEN
/*
* If we are searching start at the beginning of the block. If not searching
* skip to the offset in the block.
*/
if (search)
ffc23ce4: 81 1f 00 08 lwz r8,8(r31)
ffc23ce8: 41 92 01 34 beq- cr4,ffc23e1c <rtems_rfs_dir_del_entry+0x2a4><== ALWAYS TAKEN
ffc23cec: 38 00 00 00 li r0,0 <== NOT EXECUTED
eoffset = 0;
ffc23cf0: 3b c0 00 00 li r30,0 <== NOT EXECUTED
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
ffc23cf4: 39 48 ff f6 addi r10,r8,-10
if (search)
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
ffc23cf8: 81 21 00 14 lwz r9,20(r1)
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
ffc23cfc: 7f 80 50 40 cmplw cr7,r0,r10
if (search)
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
ffc23d00: 81 29 00 24 lwz r9,36(r9)
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
ffc23d04: 40 9c 01 2c bge- cr7,ffc23e30 <rtems_rfs_dir_del_entry+0x2b8><== NEVER TAKEN
if (search)
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
ffc23d08: 7e c9 02 14 add r22,r9,r0
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
ffc23d0c: 7c 09 00 ae lbzx r0,r9,r0
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
ffc23d10: 8b 56 00 08 lbz r26,8(r22)
ffc23d14: 89 76 00 09 lbz r11,9(r22)
ffc23d18: 57 5a 40 2e rlwinm r26,r26,8,0,23
eino = rtems_rfs_dir_entry_ino (entry);
ffc23d1c: 88 f6 00 01 lbz r7,1(r22)
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
ffc23d20: 7f 5a 5b 78 or r26,r26,r11
eino = rtems_rfs_dir_entry_ino (entry);
ffc23d24: 89 36 00 03 lbz r9,3(r22)
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc23d28: 7f 9a b8 00 cmpw cr7,r26,r23
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
ffc23d2c: 89 76 00 02 lbz r11,2(r22)
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc23d30: 41 9e 01 00 beq- cr7,ffc23e30 <rtems_rfs_dir_del_entry+0x2b8><== NEVER TAKEN
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
ffc23d34: 54 f9 80 1e rlwinm r25,r7,16,0,15
ffc23d38: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc23d3c: 7f 39 5b 78 or r25,r25,r11
ffc23d40: 7f 39 4b 78 or r25,r25,r9
ffc23d44: 54 00 c0 0e rlwinm r0,r0,24,0,7
ffc23d48: 7f 39 03 78 or r25,r25,r0
ffc23d4c: 48 00 00 78 b ffc23dc4 <rtems_rfs_dir_del_entry+0x24c>
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
ffc23d50: 80 1f 00 18 lwz r0,24(r31)
ffc23d54: 7f 9a 00 40 cmplw cr7,r26,r0
ffc23d58: 40 9c 00 7c bge- cr7,ffc23dd4 <rtems_rfs_dir_del_entry+0x25c><== NEVER TAKEN
ffc23d5c: 41 9a 00 78 beq- cr6,ffc23dd4 <rtems_rfs_dir_del_entry+0x25c><== NEVER TAKEN
ffc23d60: 80 1f 00 10 lwz r0,16(r31)
ffc23d64: 7f 80 c8 40 cmplw cr7,r0,r25
ffc23d68: 41 9c 00 6c blt- cr7,ffc23dd4 <rtems_rfs_dir_del_entry+0x25c><== NEVER TAKEN
rtems_rfs_inode_ino (dir), elength, eino, block, eoffset);
rc = EIO;
break;
}
if (ino == rtems_rfs_dir_entry_ino (entry))
ffc23d6c: 41 86 01 18 beq- cr1,ffc23e84 <rtems_rfs_dir_del_entry+0x30c><== ALWAYS TAKEN
rc = EIO;
break;
}
entry += elength;
eoffset += elength;
ffc23d70: 7f de d2 14 add r30,r30,r26 <== NOT EXECUTED
{
rc = EIO;
break;
}
entry += elength;
ffc23d74: 7e d6 d2 14 add r22,r22,r26 <== NOT EXECUTED
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
ffc23d78: 7f 9e 50 40 cmplw cr7,r30,r10 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return 0;
}
if (!search)
ffc23d7c: 41 92 00 6c beq- cr4,ffc23de8 <rtems_rfs_dir_del_entry+0x270><== NOT EXECUTED
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
ffc23d80: 40 9c 00 b0 bge- cr7,ffc23e30 <rtems_rfs_dir_del_entry+0x2b8><== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
ffc23d84: 8b 56 00 08 lbz r26,8(r22) <== NOT EXECUTED
ffc23d88: 88 16 00 09 lbz r0,9(r22) <== NOT EXECUTED
ffc23d8c: 57 5a 40 2e rlwinm r26,r26,8,0,23 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
ffc23d90: 8b 36 00 00 lbz r25,0(r22) <== NOT EXECUTED
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
ffc23d94: 7f 5a 03 78 or r26,r26,r0 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
ffc23d98: 89 76 00 01 lbz r11,1(r22) <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc23d9c: 7f 9a b8 00 cmpw cr7,r26,r23 <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
ffc23da0: 89 36 00 03 lbz r9,3(r22) <== NOT EXECUTED
ffc23da4: 57 39 c0 0e rlwinm r25,r25,24,0,7 <== NOT EXECUTED
ffc23da8: 88 16 00 02 lbz r0,2(r22) <== NOT EXECUTED
ffc23dac: 55 6b 80 1e rlwinm r11,r11,16,0,15 <== NOT EXECUTED
ffc23db0: 7f 39 5b 78 or r25,r25,r11 <== NOT EXECUTED
ffc23db4: 7f 39 4b 78 or r25,r25,r9 <== NOT EXECUTED
ffc23db8: 54 00 40 2e rlwinm r0,r0,8,0,23 <== NOT EXECUTED
ffc23dbc: 7f 39 03 78 or r25,r25,r0 <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc23dc0: 41 9e 00 70 beq- cr7,ffc23e30 <rtems_rfs_dir_del_entry+0x2b8><== NOT EXECUTED
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
ffc23dc4: 2f 9a 00 0a cmpwi cr7,r26,10
ffc23dc8: 2f 19 00 00 cmpwi cr6,r25,0
rtems_rfs_inode_ino (dir), elength, eino, block, eoffset);
rc = EIO;
break;
}
if (ino == rtems_rfs_dir_entry_ino (entry))
ffc23dcc: 7c 9b c8 00 cmpw cr1,r27,r25
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
ffc23dd0: 41 9d ff 80 bgt+ cr7,ffc23d50 <rtems_rfs_dir_del_entry+0x1d8><== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
ffc23dd4: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc23dd8: 3c 80 40 00 lis r4,16384 <== NOT EXECUTED
ffc23ddc: 4b ff 3b 8d bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc23de0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc23de4: 40 9e 00 78 bne- cr7,ffc23e5c <rtems_rfs_dir_del_entry+0x2e4><== NOT EXECUTED
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc == ENXIO)
rc = ENOENT;
ffc23de8: 3b 00 00 05 li r24,5 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc23dec: 38 81 00 0c addi r4,r1,12 <== NOT EXECUTED
ffc23df0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc23df4: 4b ff e8 4d bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
ffc23df8: 38 00 00 00 li r0,0 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc23dfc: 39 20 00 00 li r9,0 <== NOT EXECUTED
handle->bnum = 0;
ffc23e00: 90 01 00 10 stw r0,16(r1) <== NOT EXECUTED
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
ffc23e04: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc23e08: 38 81 00 18 addi r4,r1,24 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc23e0c: 99 21 00 0c stb r9,12(r1) <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
ffc23e10: 90 01 00 14 stw r0,20(r1) <== NOT EXECUTED
ffc23e14: 4b ff d9 4d bl ffc21760 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
ffc23e18: 4b ff fd d8 b ffc23bf0 <rtems_rfs_dir_del_entry+0x78><== NOT EXECUTED
* skip to the offset in the block.
*/
if (search)
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
ffc23e1c: 7f dc 43 96 divwu r30,r28,r8
ffc23e20: 7f de 41 d6 mullw r30,r30,r8
ffc23e24: 7f de e0 50 subf r30,r30,r28
ffc23e28: 7f c0 f3 78 mr r0,r30
ffc23e2c: 4b ff fe c8 b ffc23cf4 <rtems_rfs_dir_del_entry+0x17c>
entry += elength;
eoffset += elength;
}
if (rc == 0)
ffc23e30: 40 a2 ff bc bne- ffc23dec <rtems_rfs_dir_del_entry+0x274><== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
ffc23e34: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc23e38: 38 81 00 18 addi r4,r1,24 <== NOT EXECUTED
ffc23e3c: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
ffc23e40: 4b ff dd a1 bl ffc21be0 <rtems_rfs_block_map_next_block><== NOT EXECUTED
if (rc == ENXIO)
ffc23e44: 2f 83 00 06 cmpwi cr7,r3,6 <== NOT EXECUTED
eoffset += elength;
}
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
ffc23e48: 7c 78 1b 78 mr r24,r3 <== NOT EXECUTED
if (rc == ENXIO)
ffc23e4c: 41 9e 01 9c beq- cr7,ffc23fe8 <rtems_rfs_dir_del_entry+0x470><== NOT EXECUTED
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
while (rc == 0)
ffc23e50: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc23e54: 41 9e fe 74 beq+ cr7,ffc23cc8 <rtems_rfs_dir_del_entry+0x150><== NOT EXECUTED
ffc23e58: 4b ff ff 94 b ffc23dec <rtems_rfs_dir_del_entry+0x274><== NOT EXECUTED
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: "
ffc23e5c: 80 9d 00 08 lwz r4,8(r29) <== NOT EXECUTED
ffc23e60: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc23e64: 80 e1 00 08 lwz r7,8(r1) <== NOT EXECUTED
ffc23e68: 7f 45 d3 78 mr r5,r26 <== NOT EXECUTED
ffc23e6c: 7f 26 cb 78 mr r6,r25 <== NOT EXECUTED
ffc23e70: 7f c8 f3 78 mr r8,r30 <== NOT EXECUTED
ffc23e74: 38 63 d1 7c addi r3,r3,-11908 <== NOT EXECUTED
ffc23e78: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc23e7c: 48 00 6e c9 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc23e80: 4b ff ff 68 b ffc23de8 <rtems_rfs_dir_del_entry+0x270><== NOT EXECUTED
}
if (ino == rtems_rfs_dir_entry_ino (entry))
{
uint32_t remaining;
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
ffc23e84: 7f 9a f2 14 add r28,r26,r30
ffc23e88: 7f 9c 40 50 subf r28,r28,r8
memmove (entry, entry + elength, remaining);
ffc23e8c: 7f 85 e3 78 mr r5,r28
ffc23e90: 7c 96 d2 14 add r4,r22,r26
ffc23e94: 7e c3 b3 78 mr r3,r22
ffc23e98: 48 00 6b e9 bl ffc2aa80 <memmove>
memset (entry + remaining, 0xff, elength);
ffc23e9c: 38 80 00 ff li r4,255
ffc23ea0: 7f 45 d3 78 mr r5,r26
ffc23ea4: 7c 76 e2 14 add r3,r22,r28
ffc23ea8: 48 00 6d 0d bl ffc2abb4 <memset>
* block and it is the last block in the map shrink the map.
*
* @note We could check again to see if the new end block in the map is
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
ffc23eac: 8b 96 00 08 lbz r28,8(r22)
ffc23eb0: 88 16 00 09 lbz r0,9(r22)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
ffc23eb4: 38 60 00 00 li r3,0
* block and it is the last block in the map shrink the map.
*
* @note We could check again to see if the new end block in the map is
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
ffc23eb8: 57 9c 40 2e rlwinm r28,r28,8,0,23
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
ffc23ebc: 3c 80 40 00 lis r4,16384
* block and it is the last block in the map shrink the map.
*
* @note We could check again to see if the new end block in the map is
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
ffc23ec0: 7f 9c 03 78 or r28,r28,r0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
ffc23ec4: 4b ff 3a a5 bl ffc17968 <rtems_rfs_trace>
ffc23ec8: 2f 83 00 00 cmpwi cr7,r3,0
ffc23ecc: 41 9e 00 44 beq- cr7,ffc23f10 <rtems_rfs_dir_del_entry+0x398><== ALWAYS TAKEN
printf ("rtems-rfs: dir-del-entry: "
"last block free for ino %" PRIu32 ": elength=%i block=%" PRIu32
" offset=%d last=%s\n",
ino, elength, block, eoffset,
rtems_rfs_block_map_last (&map) ? "yes" : "no");
ffc23ed0: 80 01 00 28 lwz r0,40(r1) <== NOT EXECUTED
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: "
ffc23ed4: 80 c1 00 08 lwz r6,8(r1) <== NOT EXECUTED
ffc23ed8: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
"last block free for ino %" PRIu32 ": elength=%i block=%" PRIu32
" offset=%d last=%s\n",
ino, elength, block, eoffset,
rtems_rfs_block_map_last (&map) ? "yes" : "no");
ffc23edc: 81 21 00 20 lwz r9,32(r1) <== NOT EXECUTED
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: "
ffc23ee0: 40 9e 00 f0 bne- cr7,ffc23fd0 <rtems_rfs_dir_del_entry+0x458><== NOT EXECUTED
"last block free for ino %" PRIu32 ": elength=%i block=%" PRIu32
" offset=%d last=%s\n",
ino, elength, block, eoffset,
rtems_rfs_block_map_last (&map) ? "yes" : "no");
ffc23ee4: 2f 89 00 00 cmpwi cr7,r9,0 <== NOT EXECUTED
ffc23ee8: 40 9e 00 e8 bne- cr7,ffc23fd0 <rtems_rfs_dir_del_entry+0x458><== NOT EXECUTED
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: "
ffc23eec: 3d 00 ff c4 lis r8,-60 <== NOT EXECUTED
ffc23ef0: 39 08 b9 38 addi r8,r8,-18120 <== NOT EXECUTED
ffc23ef4: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc23ef8: 38 63 d1 c8 addi r3,r3,-11832 <== NOT EXECUTED
ffc23efc: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc23f00: 7f 85 e3 78 mr r5,r28 <== NOT EXECUTED
ffc23f04: 7f c7 f3 78 mr r7,r30 <== NOT EXECUTED
ffc23f08: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc23f0c: 48 00 6e 39 bl ffc2ad44 <printf> <== NOT EXECUTED
"last block free for ino %" PRIu32 ": elength=%i block=%" PRIu32
" offset=%d last=%s\n",
ino, elength, block, eoffset,
rtems_rfs_block_map_last (&map) ? "yes" : "no");
if ((elength == RTEMS_RFS_DIR_ENTRY_EMPTY) &&
ffc23f10: 6f 80 ff ff xoris r0,r28,65535
ffc23f14: 2f 80 ff ff cmpwi cr7,r0,-1
ffc23f18: 41 9e 00 40 beq- cr7,ffc23f58 <rtems_rfs_dir_del_entry+0x3e0>
"block map shrink failed for ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (dir), rc, strerror (rc));
}
}
rtems_rfs_buffer_mark_dirty (&buffer);
ffc23f1c: 38 00 00 01 li r0,1
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc23f20: 38 81 00 0c addi r4,r1,12
ffc23f24: 98 01 00 0c stb r0,12(r1)
ffc23f28: 7f e3 fb 78 mr r3,r31
ffc23f2c: 4b ff e7 15 bl ffc22640 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
handle->bnum = 0;
ffc23f30: 38 00 00 00 li r0,0
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc23f34: 39 20 00 00 li r9,0
handle->bnum = 0;
ffc23f38: 90 01 00 10 stw r0,16(r1)
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
ffc23f3c: 7f e3 fb 78 mr r3,r31
ffc23f40: 38 81 00 18 addi r4,r1,24
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc23f44: 99 21 00 0c stb r9,12(r1)
return 0;
ffc23f48: 3b 00 00 00 li r24,0
handle->bnum = 0;
handle->buffer = NULL;
ffc23f4c: 90 01 00 14 stw r0,20(r1)
}
}
rtems_rfs_buffer_mark_dirty (&buffer);
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
ffc23f50: 4b ff d8 11 bl ffc21760 <rtems_rfs_block_map_close>
return 0;
ffc23f54: 4b ff fc 9c b ffc23bf0 <rtems_rfs_dir_del_entry+0x78>
"last block free for ino %" PRIu32 ": elength=%i block=%" PRIu32
" offset=%d last=%s\n",
ino, elength, block, eoffset,
rtems_rfs_block_map_last (&map) ? "yes" : "no");
if ((elength == RTEMS_RFS_DIR_ENTRY_EMPTY) &&
ffc23f58: 2f 9e 00 00 cmpwi cr7,r30,0
ffc23f5c: 40 be ff c0 bne- cr7,ffc23f1c <rtems_rfs_dir_del_entry+0x3a4><== ALWAYS TAKEN
(eoffset == 0) && rtems_rfs_block_map_last (&map))
ffc23f60: 80 01 00 28 lwz r0,40(r1) <== NOT EXECUTED
ffc23f64: 81 21 00 20 lwz r9,32(r1) <== NOT EXECUTED
ffc23f68: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc23f6c: 40 9e 00 c4 bne- cr7,ffc24030 <rtems_rfs_dir_del_entry+0x4b8><== NOT EXECUTED
ffc23f70: 2f 89 00 00 cmpwi cr7,r9,0 <== NOT EXECUTED
ffc23f74: 40 9e 00 bc bne- cr7,ffc24030 <rtems_rfs_dir_del_entry+0x4b8><== NOT EXECUTED
{
rc = rtems_rfs_block_map_shrink (fs, &map, 1);
ffc23f78: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc23f7c: 38 81 00 18 addi r4,r1,24 <== NOT EXECUTED
ffc23f80: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc23f84: 4b ff e0 c5 bl ffc22048 <rtems_rfs_block_map_shrink> <== NOT EXECUTED
if (rc > 0)
ffc23f88: 7c 7e 1b 79 mr. r30,r3 <== NOT EXECUTED
ffc23f8c: 40 a1 ff 90 ble- ffc23f1c <rtems_rfs_dir_del_entry+0x3a4><== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
ffc23f90: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc23f94: 3c 80 40 00 lis r4,16384 <== NOT EXECUTED
ffc23f98: 4b ff 39 d1 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc23f9c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc23fa0: 41 9e ff 7c beq+ cr7,ffc23f1c <rtems_rfs_dir_del_entry+0x3a4><== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
ffc23fa4: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc23fa8: 83 bd 00 08 lwz r29,8(r29) <== NOT EXECUTED
ffc23fac: 48 00 7b 05 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc23fb0: 7f c5 f3 78 mr r5,r30 <== NOT EXECUTED
ffc23fb4: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc23fb8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc23fbc: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc23fc0: 38 63 d2 28 addi r3,r3,-11736 <== NOT EXECUTED
ffc23fc4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc23fc8: 48 00 6d 7d bl ffc2ad44 <printf> <== NOT EXECUTED
ffc23fcc: 4b ff ff 50 b ffc23f1c <rtems_rfs_dir_del_entry+0x3a4><== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: "
"last block free for ino %" PRIu32 ": elength=%i block=%" PRIu32
" offset=%d last=%s\n",
ino, elength, block, eoffset,
rtems_rfs_block_map_last (&map) ? "yes" : "no");
ffc23fd0: 39 29 ff ff addi r9,r9,-1 <== NOT EXECUTED
ffc23fd4: 7f 80 48 00 cmpw cr7,r0,r9 <== NOT EXECUTED
ffc23fd8: 41 be ff 14 beq- cr7,ffc23eec <rtems_rfs_dir_del_entry+0x374><== NOT EXECUTED
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: "
ffc23fdc: 3d 00 ff c4 lis r8,-60 <== NOT EXECUTED
ffc23fe0: 39 08 be 14 addi r8,r8,-16876 <== NOT EXECUTED
ffc23fe4: 4b ff ff 10 b ffc23ef4 <rtems_rfs_dir_del_entry+0x37c><== NOT EXECUTED
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc == ENXIO)
rc = ENOENT;
ffc23fe8: 3b 00 00 02 li r24,2 <== NOT EXECUTED
ffc23fec: 4b ff fe 00 b ffc23dec <rtems_rfs_dir_del_entry+0x274><== NOT EXECUTED
int eoffset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
ffc23ff0: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc23ff4: 3c 80 40 00 lis r4,16384 <== NOT EXECUTED
ffc23ff8: 4b ff 39 71 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc23ffc: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc24000: 41 9e fd ec beq+ cr7,ffc23dec <rtems_rfs_dir_del_entry+0x274><== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
ffc24004: 7f 03 c3 78 mr r3,r24 <== NOT EXECUTED
ffc24008: 83 dd 00 08 lwz r30,8(r29) <== NOT EXECUTED
ffc2400c: 48 00 7a a5 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc24010: 7f 05 c3 78 mr r5,r24 <== NOT EXECUTED
ffc24014: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc24018: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc2401c: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc24020: 38 63 d1 34 addi r3,r3,-11980 <== NOT EXECUTED
ffc24024: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc24028: 48 00 6d 1d bl ffc2ad44 <printf> <== NOT EXECUTED
ffc2402c: 4b ff fd c0 b ffc23dec <rtems_rfs_dir_del_entry+0x274><== NOT EXECUTED
" offset=%d last=%s\n",
ino, elength, block, eoffset,
rtems_rfs_block_map_last (&map) ? "yes" : "no");
if ((elength == RTEMS_RFS_DIR_ENTRY_EMPTY) &&
(eoffset == 0) && rtems_rfs_block_map_last (&map))
ffc24030: 39 29 ff ff addi r9,r9,-1 <== NOT EXECUTED
ffc24034: 7f 80 48 00 cmpw cr7,r0,r9 <== NOT EXECUTED
ffc24038: 40 9e fe e4 bne+ cr7,ffc23f1c <rtems_rfs_dir_del_entry+0x3a4><== NOT EXECUTED
ffc2403c: 4b ff ff 3c b ffc23f78 <rtems_rfs_dir_del_entry+0x400><== NOT EXECUTED
ffc24474 <rtems_rfs_dir_empty>:
}
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
ffc24474: 94 21 ff 78 stwu r1,-136(r1) <== NOT EXECUTED
ffc24478: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc2447c: 93 a1 00 7c stw r29,124(r1) <== NOT EXECUTED
ffc24480: 7c 9d 23 78 mr r29,r4 <== NOT EXECUTED
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
bool empty;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
ffc24484: 3c 80 80 00 lis r4,-32768 <== NOT EXECUTED
}
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
ffc24488: 93 e1 00 84 stw r31,132(r1) <== NOT EXECUTED
ffc2448c: 7c 7f 1b 78 mr r31,r3 <== NOT EXECUTED
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
bool empty;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
ffc24490: 38 60 00 00 li r3,0 <== NOT EXECUTED
}
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
ffc24494: 90 01 00 8c stw r0,140(r1) <== NOT EXECUTED
ffc24498: 93 01 00 68 stw r24,104(r1) <== NOT EXECUTED
ffc2449c: 93 21 00 6c stw r25,108(r1) <== NOT EXECUTED
ffc244a0: 93 41 00 70 stw r26,112(r1) <== NOT EXECUTED
ffc244a4: 93 61 00 74 stw r27,116(r1) <== NOT EXECUTED
ffc244a8: 93 81 00 78 stw r28,120(r1) <== NOT EXECUTED
ffc244ac: 93 c1 00 80 stw r30,128(r1) <== NOT EXECUTED
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
bool empty;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
ffc244b0: 4b ff 34 b9 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc244b4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc244b8: 40 9e 00 50 bne- cr7,ffc24508 <rtems_rfs_dir_empty+0x94><== NOT EXECUTED
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
empty = true;
rc = rtems_rfs_block_map_open (fs, dir, &map);
ffc244bc: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc244c0: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc244c4: 38 a1 00 18 addi r5,r1,24 <== NOT EXECUTED
ffc244c8: 4b ff d0 91 bl ffc21558 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
ffc244cc: 7c 78 1b 79 mr. r24,r3 <== NOT EXECUTED
ffc244d0: 40 81 00 64 ble- ffc24534 <rtems_rfs_dir_empty+0xc0> <== NOT EXECUTED
rc = ENOTEMPTY;
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
ffc244d4: 80 01 00 8c lwz r0,140(r1) <== NOT EXECUTED
ffc244d8: 7f 03 c3 78 mr r3,r24 <== NOT EXECUTED
ffc244dc: 83 21 00 6c lwz r25,108(r1) <== NOT EXECUTED
ffc244e0: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc244e4: 83 01 00 68 lwz r24,104(r1) <== NOT EXECUTED
ffc244e8: 83 41 00 70 lwz r26,112(r1) <== NOT EXECUTED
ffc244ec: 83 61 00 74 lwz r27,116(r1) <== NOT EXECUTED
ffc244f0: 83 81 00 78 lwz r28,120(r1) <== NOT EXECUTED
ffc244f4: 83 a1 00 7c lwz r29,124(r1) <== NOT EXECUTED
ffc244f8: 83 c1 00 80 lwz r30,128(r1) <== NOT EXECUTED
ffc244fc: 83 e1 00 84 lwz r31,132(r1) <== NOT EXECUTED
ffc24500: 38 21 00 88 addi r1,r1,136 <== NOT EXECUTED
ffc24504: 4e 80 00 20 blr <== NOT EXECUTED
rtems_rfs_block_no block;
bool empty;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
ffc24508: 80 9d 00 08 lwz r4,8(r29) <== NOT EXECUTED
ffc2450c: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc24510: 38 63 d3 50 addi r3,r3,-11440 <== NOT EXECUTED
ffc24514: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc24518: 48 00 68 2d bl ffc2ad44 <printf> <== NOT EXECUTED
empty = true;
rc = rtems_rfs_block_map_open (fs, dir, &map);
ffc2451c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc24520: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc24524: 38 a1 00 18 addi r5,r1,24 <== NOT EXECUTED
ffc24528: 4b ff d0 31 bl ffc21558 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
ffc2452c: 7c 78 1b 79 mr. r24,r3 <== NOT EXECUTED
ffc24530: 41 81 ff a4 bgt+ ffc244d4 <rtems_rfs_dir_empty+0x60> <== NOT EXECUTED
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
ffc24534: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc24538: 38 81 00 18 addi r4,r1,24 <== NOT EXECUTED
ffc2453c: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc24540: 38 c0 00 00 li r6,0 <== NOT EXECUTED
ffc24544: 38 e1 00 08 addi r7,r1,8 <== NOT EXECUTED
ffc24548: 4b ff d5 d5 bl ffc21b1c <rtems_rfs_block_map_seek> <== NOT EXECUTED
if (rc > 0)
ffc2454c: 7c 78 1b 79 mr. r24,r3 <== NOT EXECUTED
ffc24550: 41 81 02 14 bgt- ffc24764 <rtems_rfs_dir_empty+0x2f0> <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
handle->bnum = 0;
ffc24554: 38 00 00 00 li r0,0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc24558: 39 20 00 00 li r9,0 <== NOT EXECUTED
handle->bnum = 0;
ffc2455c: 90 01 00 10 stw r0,16(r1) <== NOT EXECUTED
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc24560: 3b c0 00 00 li r30,0 <== NOT EXECUTED
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
printf ("rtems-rfs: dir-empty: "
ffc24564: 3f 80 ff c4 lis r28,-60 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc24568: 99 21 00 0c stb r9,12(r1) <== NOT EXECUTED
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc2456c: 63 de ff ff ori r30,r30,65535 <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
ffc24570: 90 01 00 14 stw r0,20(r1) <== NOT EXECUTED
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
printf ("rtems-rfs: dir-empty: "
ffc24574: 3b 9c d3 70 addi r28,r28,-11408 <== NOT EXECUTED
while (empty)
{
uint8_t* entry;
int offset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
ffc24578: 80 a1 00 08 lwz r5,8(r1) <== NOT EXECUTED
ffc2457c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc24580: 38 81 00 0c addi r4,r1,12 <== NOT EXECUTED
ffc24584: 38 c0 00 01 li r6,1 <== NOT EXECUTED
ffc24588: 4b ff e2 cd bl ffc22854 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
if (rc > 0)
ffc2458c: 7c 78 1b 79 mr. r24,r3 <== NOT EXECUTED
ffc24590: 41 81 01 18 bgt- ffc246a8 <rtems_rfs_dir_empty+0x234> <== NOT EXECUTED
break;
entry = rtems_rfs_buffer_data (&buffer);
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
ffc24594: 81 1f 00 08 lwz r8,8(r31) <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
break;
entry = rtems_rfs_buffer_data (&buffer);
ffc24598: 81 21 00 14 lwz r9,20(r1) <== NOT EXECUTED
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
ffc2459c: 39 08 ff f6 addi r8,r8,-10 <== NOT EXECUTED
ffc245a0: 2f 88 00 00 cmpwi cr7,r8,0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
break;
entry = rtems_rfs_buffer_data (&buffer);
ffc245a4: 81 29 00 24 lwz r9,36(r9) <== NOT EXECUTED
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
ffc245a8: 41 9e 01 74 beq- cr7,ffc2471c <rtems_rfs_dir_empty+0x2a8><== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
ffc245ac: 8b 29 00 08 lbz r25,8(r9) <== NOT EXECUTED
ffc245b0: 88 09 00 09 lbz r0,9(r9) <== NOT EXECUTED
ffc245b4: 57 39 40 2e rlwinm r25,r25,8,0,23 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
ffc245b8: 89 49 00 01 lbz r10,1(r9) <== NOT EXECUTED
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
ffc245bc: 7f 39 03 78 or r25,r25,r0 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
ffc245c0: 88 e9 00 02 lbz r7,2(r9) <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc245c4: 7f 99 f0 00 cmpw cr7,r25,r30 <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
ffc245c8: 88 09 00 00 lbz r0,0(r9) <== NOT EXECUTED
ffc245cc: 89 69 00 03 lbz r11,3(r9) <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc245d0: 41 9e 01 4c beq- cr7,ffc2471c <rtems_rfs_dir_empty+0x2a8><== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
ffc245d4: 54 fa 40 2e rlwinm r26,r7,8,0,23 <== NOT EXECUTED
ffc245d8: 55 4a 80 1e rlwinm r10,r10,16,0,15 <== NOT EXECUTED
ffc245dc: 7f 5a 53 78 or r26,r26,r10 <== NOT EXECUTED
ffc245e0: 7f 5a 5b 78 or r26,r26,r11 <== NOT EXECUTED
ffc245e4: 54 00 c0 0e rlwinm r0,r0,24,0,7 <== NOT EXECUTED
ffc245e8: 7f 5a 03 78 or r26,r26,r0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
break;
entry = rtems_rfs_buffer_data (&buffer);
offset = 0;
ffc245ec: 3b 60 00 00 li r27,0 <== NOT EXECUTED
ffc245f0: 48 00 00 74 b ffc24664 <rtems_rfs_dir_empty+0x1f0> <== NOT EXECUTED
/*
* Ignore the current (.) and parent (..) entries. Anything else means
* the directory is not empty.
*/
if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&
ffc245f4: 2f 99 00 0c cmpwi cr7,r25,12 <== NOT EXECUTED
ffc245f8: 40 9e 00 a8 bne- cr7,ffc246a0 <rtems_rfs_dir_empty+0x22c><== NOT EXECUTED
((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||
ffc245fc: 88 09 00 0a lbz r0,10(r9) <== NOT EXECUTED
ffc24600: 2f 80 00 2e cmpwi cr7,r0,46 <== NOT EXECUTED
ffc24604: 40 9e 00 9c bne- cr7,ffc246a0 <rtems_rfs_dir_empty+0x22c><== NOT EXECUTED
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||
ffc24608: 88 09 00 0b lbz r0,11(r9) <== NOT EXECUTED
ffc2460c: 2f 80 00 2e cmpwi cr7,r0,46 <== NOT EXECUTED
ffc24610: 40 9e 00 90 bne- cr7,ffc246a0 <rtems_rfs_dir_empty+0x22c><== NOT EXECUTED
empty = false;
break;
}
entry += elength;
offset += elength;
ffc24614: 7f 7b ca 14 add r27,r27,r25 <== NOT EXECUTED
break;
entry = rtems_rfs_buffer_data (&buffer);
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
ffc24618: 7f 9b 40 40 cmplw cr7,r27,r8 <== NOT EXECUTED
ffc2461c: 40 9c 01 00 bge- cr7,ffc2471c <rtems_rfs_dir_empty+0x2a8><== NOT EXECUTED
{
empty = false;
break;
}
entry += elength;
ffc24620: 7d 29 ca 14 add r9,r9,r25 <== NOT EXECUTED
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
ffc24624: 8b 29 00 08 lbz r25,8(r9) <== NOT EXECUTED
ffc24628: 88 09 00 09 lbz r0,9(r9) <== NOT EXECUTED
ffc2462c: 57 39 40 2e rlwinm r25,r25,8,0,23 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
ffc24630: 8b 49 00 00 lbz r26,0(r9) <== NOT EXECUTED
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
ffc24634: 7f 39 03 78 or r25,r25,r0 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
ffc24638: 89 49 00 01 lbz r10,1(r9) <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc2463c: 7f 99 f0 00 cmpw cr7,r25,r30 <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
ffc24640: 89 69 00 03 lbz r11,3(r9) <== NOT EXECUTED
ffc24644: 57 5a c0 0e rlwinm r26,r26,24,0,7 <== NOT EXECUTED
ffc24648: 88 09 00 02 lbz r0,2(r9) <== NOT EXECUTED
ffc2464c: 55 4a 80 1e rlwinm r10,r10,16,0,15 <== NOT EXECUTED
ffc24650: 7f 5a 53 78 or r26,r26,r10 <== NOT EXECUTED
ffc24654: 7f 5a 5b 78 or r26,r26,r11 <== NOT EXECUTED
ffc24658: 54 00 40 2e rlwinm r0,r0,8,0,23 <== NOT EXECUTED
ffc2465c: 7f 5a 03 78 or r26,r26,r0 <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc24660: 41 9e 00 bc beq- cr7,ffc2471c <rtems_rfs_dir_empty+0x2a8><== NOT EXECUTED
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
ffc24664: 2f 99 00 0a cmpwi cr7,r25,10 <== NOT EXECUTED
ffc24668: 40 9d 00 a0 ble- cr7,ffc24708 <rtems_rfs_dir_empty+0x294><== NOT EXECUTED
ffc2466c: 80 1f 00 18 lwz r0,24(r31) <== NOT EXECUTED
ffc24670: 7f 99 00 40 cmplw cr7,r25,r0 <== NOT EXECUTED
ffc24674: 40 9c 00 94 bge- cr7,ffc24708 <rtems_rfs_dir_empty+0x294><== NOT EXECUTED
ffc24678: 2f 9a 00 00 cmpwi cr7,r26,0 <== NOT EXECUTED
ffc2467c: 41 9e 00 8c beq- cr7,ffc24708 <rtems_rfs_dir_empty+0x294><== NOT EXECUTED
ffc24680: 80 1f 00 10 lwz r0,16(r31) <== NOT EXECUTED
ffc24684: 7f 80 d0 40 cmplw cr7,r0,r26 <== NOT EXECUTED
ffc24688: 41 9c 00 80 blt- cr7,ffc24708 <rtems_rfs_dir_empty+0x294><== NOT EXECUTED
/*
* Ignore the current (.) and parent (..) entries. Anything else means
* the directory is not empty.
*/
if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||
ffc2468c: 2f 99 00 0b cmpwi cr7,r25,11 <== NOT EXECUTED
ffc24690: 40 9e ff 64 bne+ cr7,ffc245f4 <rtems_rfs_dir_empty+0x180><== NOT EXECUTED
ffc24694: 88 09 00 0a lbz r0,10(r9) <== NOT EXECUTED
ffc24698: 2f 80 00 2e cmpwi cr7,r0,46 <== NOT EXECUTED
ffc2469c: 41 be ff 78 beq- cr7,ffc24614 <rtems_rfs_dir_empty+0x1a0><== NOT EXECUTED
break;
}
}
}
if ((rc == 0) && !empty)
ffc246a0: 40 82 00 08 bne- ffc246a8 <rtems_rfs_dir_empty+0x234> <== NOT EXECUTED
rc = ENOTEMPTY;
ffc246a4: 3b 00 00 5a li r24,90 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc246a8: 38 81 00 0c addi r4,r1,12 <== NOT EXECUTED
ffc246ac: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc246b0: 4b ff df 91 bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
ffc246b4: 38 00 00 00 li r0,0 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
ffc246b8: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc246bc: 90 01 00 10 stw r0,16(r1) <== NOT EXECUTED
ffc246c0: 38 81 00 18 addi r4,r1,24 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc246c4: 39 20 00 00 li r9,0 <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
ffc246c8: 90 01 00 14 stw r0,20(r1) <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc246cc: 99 21 00 0c stb r9,12(r1) <== NOT EXECUTED
ffc246d0: 4b ff d0 91 bl ffc21760 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
}
ffc246d4: 7f 03 c3 78 mr r3,r24 <== NOT EXECUTED
ffc246d8: 80 01 00 8c lwz r0,140(r1) <== NOT EXECUTED
ffc246dc: 83 01 00 68 lwz r24,104(r1) <== NOT EXECUTED
ffc246e0: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc246e4: 83 21 00 6c lwz r25,108(r1) <== NOT EXECUTED
ffc246e8: 83 41 00 70 lwz r26,112(r1) <== NOT EXECUTED
ffc246ec: 83 61 00 74 lwz r27,116(r1) <== NOT EXECUTED
ffc246f0: 83 81 00 78 lwz r28,120(r1) <== NOT EXECUTED
ffc246f4: 83 a1 00 7c lwz r29,124(r1) <== NOT EXECUTED
ffc246f8: 83 c1 00 80 lwz r30,128(r1) <== NOT EXECUTED
ffc246fc: 83 e1 00 84 lwz r31,132(r1) <== NOT EXECUTED
ffc24700: 38 21 00 88 addi r1,r1,136 <== NOT EXECUTED
ffc24704: 4e 80 00 20 blr <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
ffc24708: 38 60 00 01 li r3,1 <== NOT EXECUTED
ffc2470c: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc24710: 4b ff 32 59 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc24714: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc24718: 40 9e 00 2c bne- cr7,ffc24744 <rtems_rfs_dir_empty+0x2d0><== NOT EXECUTED
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
ffc2471c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc24720: 38 81 00 18 addi r4,r1,24 <== NOT EXECUTED
ffc24724: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
ffc24728: 4b ff d4 b9 bl ffc21be0 <rtems_rfs_block_map_next_block><== NOT EXECUTED
if (rc > 0)
ffc2472c: 7c 78 1b 79 mr. r24,r3 <== NOT EXECUTED
ffc24730: 40 81 fe 48 ble+ ffc24578 <rtems_rfs_dir_empty+0x104> <== NOT EXECUTED
{
if (rc == ENXIO)
ffc24734: 2f 98 00 06 cmpwi cr7,r24,6 <== NOT EXECUTED
ffc24738: 40 9e ff 70 bne+ cr7,ffc246a8 <rtems_rfs_dir_empty+0x234><== NOT EXECUTED
ffc2473c: 3b 00 00 00 li r24,0 <== NOT EXECUTED
ffc24740: 4b ff ff 68 b ffc246a8 <rtems_rfs_dir_empty+0x234> <== NOT EXECUTED
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
printf ("rtems-rfs: dir-empty: "
ffc24744: 80 9d 00 08 lwz r4,8(r29) <== NOT EXECUTED
ffc24748: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc2474c: 7f 25 cb 78 mr r5,r25 <== NOT EXECUTED
ffc24750: 7f 46 d3 78 mr r6,r26 <== NOT EXECUTED
ffc24754: 7f 67 db 78 mr r7,r27 <== NOT EXECUTED
ffc24758: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc2475c: 48 00 65 e9 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc24760: 4b ff ff bc b ffc2471c <rtems_rfs_dir_empty+0x2a8> <== NOT EXECUTED
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
if (rc > 0)
{
rtems_rfs_block_map_close (fs, &map);
ffc24764: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc24768: 38 81 00 18 addi r4,r1,24 <== NOT EXECUTED
ffc2476c: 4b ff cf f5 bl ffc21760 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
ffc24770: 4b ff fd 64 b ffc244d4 <rtems_rfs_dir_empty+0x60> <== NOT EXECUTED
ffc29968 <rtems_rfs_dir_hash>:
} else { /* need to read the key one byte at a time */
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
ffc29968: 2b 84 00 0c cmplwi cr7,r4,12
*/
#define initval (20010928)
uint32_t
rtems_rfs_dir_hash (const void *key, size_t length)
{
ffc2996c: 94 21 ff e8 stwu r1,-24(r1)
uint32_t a,b,c; /* internal state */
union { const void *ptr; size_t i; } u; /* needed for Mac Powerbook G4 */
/* Set up the internal state */
a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
ffc29970: 3d 24 df df addis r9,r4,-8225
ffc29974: 39 29 16 9f addi r9,r9,5791
*/
#define initval (20010928)
uint32_t
rtems_rfs_dir_hash (const void *key, size_t length)
{
ffc29978: 93 a1 00 0c stw r29,12(r1)
} else { /* need to read the key one byte at a time */
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
ffc2997c: 7c 6b 1b 78 mr r11,r3
*/
#define initval (20010928)
uint32_t
rtems_rfs_dir_hash (const void *key, size_t length)
{
ffc29980: 93 c1 00 10 stw r30,16(r1)
} else { /* need to read the key one byte at a time */
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
ffc29984: 7d 20 4b 78 mr r0,r9
ffc29988: 7d 2a 4b 78 mr r10,r9
*/
#define initval (20010928)
uint32_t
rtems_rfs_dir_hash (const void *key, size_t length)
{
ffc2998c: 93 e1 00 14 stw r31,20(r1)
} else { /* need to read the key one byte at a time */
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
ffc29990: 40 9d 00 f8 ble- cr7,ffc29a88 <rtems_rfs_dir_hash+0x120>
{
a += k[0];
ffc29994: 88 eb 00 00 lbz r7,0(r11)
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
length -= 12;
ffc29998: 38 84 ff f4 addi r4,r4,-12
a += ((uint32_t)k[3])<<24;
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
ffc2999c: 88 cb 00 08 lbz r6,8(r11)
} else { /* need to read the key one byte at a time */
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
ffc299a0: 2b 84 00 0c cmplwi cr7,r4,12
{
a += k[0];
a += ((uint32_t)k[1])<<8;
ffc299a4: 8b ab 00 01 lbz r29,1(r11)
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
ffc299a8: 7d 47 52 14 add r10,r7,r10
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
ffc299ac: 89 0b 00 09 lbz r8,9(r11)
a += ((uint32_t)k[3])<<24;
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
ffc299b0: 7d 26 4a 14 add r9,r6,r9
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
ffc299b4: 8b eb 00 02 lbz r31,2(r11)
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
ffc299b8: 57 bd 40 2e rlwinm r29,r29,8,0,23
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
ffc299bc: 89 8b 00 0a lbz r12,10(r11)
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
ffc299c0: 55 08 40 2e rlwinm r8,r8,8,0,23
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
ffc299c4: 88 ab 00 03 lbz r5,3(r11)
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
ffc299c8: 7d 09 42 14 add r8,r9,r8
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
ffc299cc: 8b cb 00 04 lbz r30,4(r11)
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
ffc299d0: 7d 4a ea 14 add r10,r10,r29
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
b += ((uint32_t)k[5])<<8;
ffc299d4: 88 eb 00 05 lbz r7,5(r11)
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
ffc299d8: 57 ff 80 1e rlwinm r31,r31,16,0,15
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
ffc299dc: 88 6b 00 0b lbz r3,11(r11)
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
ffc299e0: 55 8c 80 1e rlwinm r12,r12,16,0,15
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
ffc299e4: 88 cb 00 06 lbz r6,6(r11)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
ffc299e8: 7c 1e 02 14 add r0,r30,r0
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
ffc299ec: 89 2b 00 07 lbz r9,7(r11)
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
ffc299f0: 7d 4a fa 14 add r10,r10,r31
a += ((uint32_t)k[3])<<24;
ffc299f4: 54 a5 c0 0e rlwinm r5,r5,24,0,7
b += k[4];
b += ((uint32_t)k[5])<<8;
ffc299f8: 54 e7 40 2e rlwinm r7,r7,8,0,23
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
ffc299fc: 7d 08 62 14 add r8,r8,r12
c += ((uint32_t)k[11])<<24;
ffc29a00: 54 63 c0 0e rlwinm r3,r3,24,0,7
ffc29a04: 7d 08 1a 14 add r8,r8,r3
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
b += ((uint32_t)k[5])<<8;
ffc29a08: 7c e0 3a 14 add r7,r0,r7
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
ffc29a0c: 7d 4a 2a 14 add r10,r10,r5
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
ffc29a10: 54 c6 80 1e rlwinm r6,r6,16,0,15
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
ffc29a14: 55 00 20 3e rotlwi r0,r8,4
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
ffc29a18: 55 29 c0 0e rlwinm r9,r9,24,0,7
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
ffc29a1c: 7d 48 50 50 subf r10,r8,r10
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
ffc29a20: 7c e7 32 14 add r7,r7,r6
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
ffc29a24: 7d 4a 02 78 xor r10,r10,r0
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
ffc29a28: 7c e7 4a 14 add r7,r7,r9
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
ffc29a2c: 7c 0a 38 50 subf r0,r10,r7
ffc29a30: 55 49 30 3e rotlwi r9,r10,6
ffc29a34: 7d 20 02 78 xor r0,r9,r0
ffc29a38: 7d 08 3a 14 add r8,r8,r7
ffc29a3c: 7d 20 40 50 subf r9,r0,r8
ffc29a40: 54 07 40 3e rotlwi r7,r0,8
ffc29a44: 7c e9 4a 78 xor r9,r7,r9
ffc29a48: 7d 0a 42 14 add r8,r10,r8
ffc29a4c: 7d 49 40 50 subf r10,r9,r8
ffc29a50: 55 27 80 3e rotlwi r7,r9,16
ffc29a54: 7c ea 52 78 xor r10,r7,r10
ffc29a58: 7d 00 42 14 add r8,r0,r8
ffc29a5c: 7c 0a 40 50 subf r0,r10,r8
ffc29a60: 55 47 98 3e rotlwi r7,r10,19
ffc29a64: 7c e0 02 78 xor r0,r7,r0
ffc29a68: 7d 29 42 14 add r9,r9,r8
ffc29a6c: 7d 4a 4a 14 add r10,r10,r9
ffc29a70: 54 08 20 3e rotlwi r8,r0,4
ffc29a74: 7d 20 48 50 subf r9,r0,r9
ffc29a78: 7d 09 4a 78 xor r9,r8,r9
ffc29a7c: 7c 00 52 14 add r0,r0,r10
length -= 12;
k += 12;
ffc29a80: 39 6b 00 0c addi r11,r11,12
} else { /* need to read the key one byte at a time */
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
ffc29a84: 41 9d ff 10 bgt+ cr7,ffc29994 <rtems_rfs_dir_hash+0x2c> <== NEVER TAKEN
length -= 12;
k += 12;
}
/*-------------------------------- last block: affect all 32 bits of (c) */
switch(length) /* all the case statements fall through */
ffc29a88: 2b 84 00 0c cmplwi cr7,r4,12
ffc29a8c: 41 9d 00 f8 bgt- cr7,ffc29b84 <rtems_rfs_dir_hash+0x21c><== NEVER TAKEN
ffc29a90: 3d 00 ff c4 lis r8,-60
ffc29a94: 39 08 de 0c addi r8,r8,-8692
ffc29a98: 54 84 10 3a rlwinm r4,r4,2,0,29
ffc29a9c: 7c e8 20 2e lwzx r7,r8,r4
ffc29aa0: 7d 07 42 14 add r8,r7,r8
ffc29aa4: 7d 09 03 a6 mtctr r8
ffc29aa8: 4e 80 04 20 bctr
{
case 12: c+=((uint32_t)k[11])<<24;
ffc29aac: 89 0b 00 0b lbz r8,11(r11)
ffc29ab0: 55 08 c0 0e rlwinm r8,r8,24,0,7
ffc29ab4: 7d 29 42 14 add r9,r9,r8
case 11: c+=((uint32_t)k[10])<<16;
ffc29ab8: 89 0b 00 0a lbz r8,10(r11)
ffc29abc: 55 08 80 1e rlwinm r8,r8,16,0,15
ffc29ac0: 7d 29 42 14 add r9,r9,r8
case 10: c+=((uint32_t)k[9])<<8;
ffc29ac4: 89 0b 00 09 lbz r8,9(r11)
ffc29ac8: 55 08 40 2e rlwinm r8,r8,8,0,23
ffc29acc: 7d 29 42 14 add r9,r9,r8
case 9 : c+=k[8];
ffc29ad0: 89 0b 00 08 lbz r8,8(r11)
ffc29ad4: 7d 29 42 14 add r9,r9,r8
case 8 : b+=((uint32_t)k[7])<<24;
ffc29ad8: 89 0b 00 07 lbz r8,7(r11)
ffc29adc: 55 08 c0 0e rlwinm r8,r8,24,0,7
ffc29ae0: 7c 00 42 14 add r0,r0,r8
case 7 : b+=((uint32_t)k[6])<<16;
ffc29ae4: 89 0b 00 06 lbz r8,6(r11)
ffc29ae8: 55 08 80 1e rlwinm r8,r8,16,0,15
ffc29aec: 7c 00 42 14 add r0,r0,r8
case 6 : b+=((uint32_t)k[5])<<8;
ffc29af0: 89 0b 00 05 lbz r8,5(r11)
ffc29af4: 55 08 40 2e rlwinm r8,r8,8,0,23
ffc29af8: 7c 00 42 14 add r0,r0,r8
case 5 : b+=k[4];
ffc29afc: 89 0b 00 04 lbz r8,4(r11)
ffc29b00: 7c 00 42 14 add r0,r0,r8
case 4 : a+=((uint32_t)k[3])<<24;
ffc29b04: 89 0b 00 03 lbz r8,3(r11)
ffc29b08: 55 08 c0 0e rlwinm r8,r8,24,0,7
ffc29b0c: 7d 4a 42 14 add r10,r10,r8
case 3 : a+=((uint32_t)k[2])<<16;
ffc29b10: 89 0b 00 02 lbz r8,2(r11)
ffc29b14: 55 08 80 1e rlwinm r8,r8,16,0,15
ffc29b18: 7d 4a 42 14 add r10,r10,r8
case 2 : a+=((uint32_t)k[1])<<8;
ffc29b1c: 89 0b 00 01 lbz r8,1(r11)
ffc29b20: 55 08 40 2e rlwinm r8,r8,8,0,23
ffc29b24: 7d 4a 42 14 add r10,r10,r8
case 1 : a+=k[0];
ffc29b28: 89 0b 00 00 lbz r8,0(r11)
break;
case 0 : return c;
}
}
final(a,b,c);
ffc29b2c: 7d 29 02 78 xor r9,r9,r0
ffc29b30: 54 0b 70 3e rotlwi r11,r0,14
ffc29b34: 7d 2b 48 50 subf r9,r11,r9
case 6 : b+=((uint32_t)k[5])<<8;
case 5 : b+=k[4];
case 4 : a+=((uint32_t)k[3])<<24;
case 3 : a+=((uint32_t)k[2])<<16;
case 2 : a+=((uint32_t)k[1])<<8;
case 1 : a+=k[0];
ffc29b38: 7d 4a 42 14 add r10,r10,r8
break;
case 0 : return c;
}
}
final(a,b,c);
ffc29b3c: 55 2b 58 3e rotlwi r11,r9,11
ffc29b40: 7d 2a 52 78 xor r10,r9,r10
ffc29b44: 7d 4b 50 50 subf r10,r11,r10
ffc29b48: 55 4b c8 3e rotlwi r11,r10,25
ffc29b4c: 7d 40 02 78 xor r0,r10,r0
ffc29b50: 7c 0b 00 50 subf r0,r11,r0
ffc29b54: 7c 09 4a 78 xor r9,r0,r9
ffc29b58: 54 08 80 3e rotlwi r8,r0,16
ffc29b5c: 7d 68 48 50 subf r11,r8,r9
ffc29b60: 55 69 20 3e rotlwi r9,r11,4
ffc29b64: 7d 6a 52 78 xor r10,r11,r10
ffc29b68: 7d 49 50 50 subf r10,r9,r10
ffc29b6c: 7d 40 02 78 xor r0,r10,r0
ffc29b70: 55 4a 70 3e rotlwi r10,r10,14
ffc29b74: 7c 0a 00 50 subf r0,r10,r0
ffc29b78: 7c 09 5a 78 xor r9,r0,r11
ffc29b7c: 54 00 c0 3e rotlwi r0,r0,24
ffc29b80: 7d 20 48 50 subf r9,r0,r9
return c;
}
ffc29b84: 7d 23 4b 78 mr r3,r9
ffc29b88: 83 a1 00 0c lwz r29,12(r1)
ffc29b8c: 83 c1 00 10 lwz r30,16(r1)
ffc29b90: 83 e1 00 14 lwz r31,20(r1)
ffc29b94: 38 21 00 18 addi r1,r1,24
ffc29b98: 4e 80 00 20 blr
ffc230b4 <rtems_rfs_dir_lookup_ino>:
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
ffc230b4: 94 21 ff 50 stwu r1,-176(r1)
ffc230b8: 7d 80 00 26 mfcr r12
ffc230bc: 7c 08 02 a6 mflr r0
ffc230c0: 92 e1 00 8c stw r23,140(r1)
ffc230c4: 7c 97 23 78 mr r23,r4
rtems_rfs_block_map map;
rtems_rfs_buffer_handle entries;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
ffc230c8: 3c 80 04 00 lis r4,1024
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
ffc230cc: 93 a1 00 a4 stw r29,164(r1)
ffc230d0: 7c 7d 1b 78 mr r29,r3
rtems_rfs_block_map map;
rtems_rfs_buffer_handle entries;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
ffc230d4: 38 60 00 00 li r3,0
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
ffc230d8: 92 81 00 80 stw r20,128(r1)
ffc230dc: 7d 14 43 78 mr r20,r8
ffc230e0: 93 01 00 90 stw r24,144(r1)
ffc230e4: 7c b8 2b 78 mr r24,r5
ffc230e8: 93 21 00 94 stw r25,148(r1)
ffc230ec: 7c d9 33 78 mr r25,r6
ffc230f0: 93 81 00 a0 stw r28,160(r1)
ffc230f4: 7c fc 3b 78 mr r28,r7
ffc230f8: 90 01 00 b4 stw r0,180(r1)
ffc230fc: 92 01 00 70 stw r16,112(r1)
ffc23100: 92 21 00 74 stw r17,116(r1)
ffc23104: 92 41 00 78 stw r18,120(r1)
ffc23108: 92 61 00 7c stw r19,124(r1)
ffc2310c: 92 a1 00 84 stw r21,132(r1)
ffc23110: 92 c1 00 88 stw r22,136(r1)
ffc23114: 93 41 00 98 stw r26,152(r1)
ffc23118: 93 61 00 9c stw r27,156(r1)
ffc2311c: 93 c1 00 a8 stw r30,168(r1)
ffc23120: 93 e1 00 ac stw r31,172(r1)
ffc23124: 91 81 00 6c stw r12,108(r1)
rtems_rfs_block_map map;
rtems_rfs_buffer_handle entries;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
ffc23128: 4b ff 48 41 bl ffc17968 <rtems_rfs_trace>
ffc2312c: 2f 83 00 00 cmpwi cr7,r3,0
ffc23130: 40 9e 00 98 bne- cr7,ffc231c8 <rtems_rfs_dir_lookup_ino+0x114><== NEVER TAKEN
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (", len=%d\n", length);
}
*ino = RTEMS_RFS_EMPTY_INO;
ffc23134: 3b e0 00 00 li r31,0
ffc23138: 93 fc 00 00 stw r31,0(r28)
*offset = 0;
rc = rtems_rfs_block_map_open (fs, inode, &map);
ffc2313c: 7f a3 eb 78 mr r3,r29
ffc23140: 7e e4 bb 78 mr r4,r23
printf ("%c", name[c]);
printf (", len=%d\n", length);
}
*ino = RTEMS_RFS_EMPTY_INO;
*offset = 0;
ffc23144: 93 f4 00 00 stw r31,0(r20)
rc = rtems_rfs_block_map_open (fs, inode, &map);
ffc23148: 38 a1 00 18 addi r5,r1,24
ffc2314c: 4b ff e4 0d bl ffc21558 <rtems_rfs_block_map_open>
if (rc > 0)
ffc23150: 7c 76 1b 79 mr. r22,r3
ffc23154: 40 81 00 e0 ble- ffc23234 <rtems_rfs_dir_lookup_ino+0x180><== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
ffc23158: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc2315c: 3c 80 04 00 lis r4,1024 <== NOT EXECUTED
ffc23160: 4b ff 48 09 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc23164: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc23168: 40 9e 01 5c bne- cr7,ffc232c4 <rtems_rfs_dir_lookup_ino+0x210><== NOT EXECUTED
}
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
ffc2316c: 80 01 00 b4 lwz r0,180(r1)
ffc23170: 7e c3 b3 78 mr r3,r22
ffc23174: 81 81 00 6c lwz r12,108(r1)
ffc23178: 7c 08 03 a6 mtlr r0
ffc2317c: 82 01 00 70 lwz r16,112(r1)
ffc23180: 82 21 00 74 lwz r17,116(r1)
ffc23184: 7d 80 81 20 mtcrf 8,r12
ffc23188: 82 41 00 78 lwz r18,120(r1)
ffc2318c: 82 61 00 7c lwz r19,124(r1)
ffc23190: 82 81 00 80 lwz r20,128(r1)
ffc23194: 82 a1 00 84 lwz r21,132(r1)
ffc23198: 82 c1 00 88 lwz r22,136(r1)
ffc2319c: 82 e1 00 8c lwz r23,140(r1)
ffc231a0: 83 01 00 90 lwz r24,144(r1)
ffc231a4: 83 21 00 94 lwz r25,148(r1)
ffc231a8: 83 41 00 98 lwz r26,152(r1)
ffc231ac: 83 61 00 9c lwz r27,156(r1)
ffc231b0: 83 81 00 a0 lwz r28,160(r1)
ffc231b4: 83 a1 00 a4 lwz r29,164(r1)
ffc231b8: 83 c1 00 a8 lwz r30,168(r1)
ffc231bc: 83 e1 00 ac lwz r31,172(r1)
ffc231c0: 38 21 00 b0 addi r1,r1,176
ffc231c4: 4e 80 00 20 blr
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
{
int c;
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
ffc231c8: 80 97 00 08 lwz r4,8(r23) <== NOT EXECUTED
ffc231cc: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc231d0: 38 63 cc e8 addi r3,r3,-13080 <== NOT EXECUTED
ffc231d4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc231d8: 48 00 7b 6d bl ffc2ad44 <printf> <== NOT EXECUTED
inode->ino);
for (c = 0; c < length; c++)
ffc231dc: 2f 99 00 00 cmpwi cr7,r25,0 <== NOT EXECUTED
ffc231e0: 40 9d 00 1c ble- cr7,ffc231fc <rtems_rfs_dir_lookup_ino+0x148><== NOT EXECUTED
ffc231e4: 3b e0 00 00 li r31,0 <== NOT EXECUTED
printf ("%c", name[c]);
ffc231e8: 7c 78 f8 ae lbzx r3,r24,r31 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
{
int c;
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
inode->ino);
for (c = 0; c < length; c++)
ffc231ec: 3b ff 00 01 addi r31,r31,1 <== NOT EXECUTED
printf ("%c", name[c]);
ffc231f0: 48 00 7c 11 bl ffc2ae00 <putchar> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
{
int c;
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
inode->ino);
for (c = 0; c < length; c++)
ffc231f4: 7f 9f c8 00 cmpw cr7,r31,r25 <== NOT EXECUTED
ffc231f8: 40 9e ff f0 bne+ cr7,ffc231e8 <rtems_rfs_dir_lookup_ino+0x134><== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%d\n", length);
ffc231fc: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc23200: 7f 24 cb 78 mr r4,r25 <== NOT EXECUTED
}
*ino = RTEMS_RFS_EMPTY_INO;
ffc23204: 3b e0 00 00 li r31,0 <== NOT EXECUTED
int c;
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
inode->ino);
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (", len=%d\n", length);
ffc23208: 38 63 cd 20 addi r3,r3,-13024 <== NOT EXECUTED
ffc2320c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc23210: 48 00 7b 35 bl ffc2ad44 <printf> <== NOT EXECUTED
}
*ino = RTEMS_RFS_EMPTY_INO;
ffc23214: 93 fc 00 00 stw r31,0(r28) <== NOT EXECUTED
*offset = 0;
rc = rtems_rfs_block_map_open (fs, inode, &map);
ffc23218: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%d\n", length);
}
*ino = RTEMS_RFS_EMPTY_INO;
*offset = 0;
ffc2321c: 93 f4 00 00 stw r31,0(r20) <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, inode, &map);
ffc23220: 7e e4 bb 78 mr r4,r23 <== NOT EXECUTED
ffc23224: 38 a1 00 18 addi r5,r1,24 <== NOT EXECUTED
ffc23228: 4b ff e3 31 bl ffc21558 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
ffc2322c: 7c 76 1b 79 mr. r22,r3 <== NOT EXECUTED
ffc23230: 41 81 ff 28 bgt+ ffc23158 <rtems_rfs_dir_lookup_ino+0xa4><== NOT EXECUTED
uint32_t hash;
/*
* Calculate the hash of the look up string.
*/
hash = rtems_rfs_dir_hash (name, length);
ffc23234: 7f 24 cb 78 mr r4,r25
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc23238: 9b e1 00 0c stb r31,12(r1)
ffc2323c: 7f 03 c3 78 mr r3,r24
handle->bnum = 0;
ffc23240: 93 e1 00 10 stw r31,16(r1)
handle->buffer = NULL;
ffc23244: 93 e1 00 14 stw r31,20(r1)
ffc23248: 48 00 67 21 bl ffc29968 <rtems_rfs_dir_hash>
ffc2324c: 7c 7a 1b 78 mr r26,r3
/*
* Locate the first block. The map points to the start after open so just
* seek 0. If an error the block will be 0.
*/
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
ffc23250: 38 81 00 18 addi r4,r1,24
ffc23254: 7f a3 eb 78 mr r3,r29
ffc23258: 38 a0 00 00 li r5,0
ffc2325c: 38 c0 00 00 li r6,0
ffc23260: 38 e1 00 08 addi r7,r1,8
ffc23264: 4b ff e8 b9 bl ffc21b1c <rtems_rfs_block_map_seek>
if (rc > 0)
ffc23268: 2e 03 00 00 cmpwi cr4,r3,0
ffc2326c: 7c 76 1b 78 mr r22,r3
ffc23270: 40 91 00 80 ble- cr4,ffc232f0 <rtems_rfs_dir_lookup_ino+0x23c>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
ffc23274: 38 60 00 00 li r3,0
ffc23278: 3c 80 04 00 lis r4,1024
ffc2327c: 4b ff 46 ed bl ffc17968 <rtems_rfs_trace>
ffc23280: 2f 83 00 00 cmpwi cr7,r3,0
ffc23284: 40 9e 03 14 bne- cr7,ffc23598 <rtems_rfs_dir_lookup_ino+0x4e4><== NEVER TAKEN
printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
rc, strerror (rc));
if (rc == ENXIO)
ffc23288: 2f 96 00 06 cmpwi cr7,r22,6
ffc2328c: 40 be 00 08 bne+ cr7,ffc23294 <rtems_rfs_dir_lookup_ino+0x1e0><== NEVER TAKEN
rc = ENOENT;
ffc23290: 3a c0 00 02 li r22,2
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc23294: 38 81 00 0c addi r4,r1,12
ffc23298: 7f a3 eb 78 mr r3,r29
ffc2329c: 4b ff f3 a5 bl ffc22640 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
handle->bnum = 0;
ffc232a0: 38 00 00 00 li r0,0
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc232a4: 39 20 00 00 li r9,0
handle->bnum = 0;
ffc232a8: 90 01 00 10 stw r0,16(r1)
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
}
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
ffc232ac: 7f a3 eb 78 mr r3,r29
ffc232b0: 38 81 00 18 addi r4,r1,24
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc232b4: 99 21 00 0c stb r9,12(r1)
handle->bnum = 0;
handle->buffer = NULL;
ffc232b8: 90 01 00 14 stw r0,20(r1)
ffc232bc: 4b ff e4 a5 bl ffc21760 <rtems_rfs_block_map_close>
return rc;
ffc232c0: 4b ff fe ac b ffc2316c <rtems_rfs_dir_lookup_ino+0xb8>
rc = rtems_rfs_block_map_open (fs, inode, &map);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: map open failed for ino %" PRIu32 ": %d: %s",
ffc232c4: 7e c3 b3 78 mr r3,r22 <== NOT EXECUTED
ffc232c8: 83 f7 00 08 lwz r31,8(r23) <== NOT EXECUTED
ffc232cc: 48 00 87 e5 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc232d0: 7e c5 b3 78 mr r5,r22 <== NOT EXECUTED
ffc232d4: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc232d8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc232dc: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc232e0: 38 63 cd 2c addi r3,r3,-13012 <== NOT EXECUTED
ffc232e4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc232e8: 48 00 7a 5d bl ffc2ad44 <printf> <== NOT EXECUTED
ffc232ec: 4b ff fe 80 b ffc2316c <rtems_rfs_dir_lookup_ino+0xb8><== NOT EXECUTED
while ((rc == 0) && block)
{
uint8_t* entry;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
ffc232f0: 3e 20 ff c4 lis r17,-60
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc232f4: 3b 60 00 00 li r27,0
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
ffc232f8: 3e 40 ff c4 lis r18,-60
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if ((rc > 0) && (rc != ENXIO))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: "
ffc232fc: 3e 00 ff c4 lis r16,-60
while ((rc == 0) && block)
{
uint8_t* entry;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
ffc23300: 3a 31 cd a8 addi r17,r17,-12888
* means the entry is empty.
*/
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
ffc23304: 3a 60 00 00 li r19,0
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc23308: 63 7b ff ff ori r27,r27,65535
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
ffc2330c: 3a 52 ce 70 addi r18,r18,-12688
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if ((rc > 0) && (rc != ENXIO))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: "
ffc23310: 3a 10 cf 18 addi r16,r16,-12520
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
ffc23314: 40 92 02 7c bne- cr4,ffc23590 <rtems_rfs_dir_lookup_ino+0x4dc><== NEVER TAKEN
ffc23318: 80 01 00 08 lwz r0,8(r1)
ffc2331c: 2f 80 00 00 cmpwi cr7,r0,0
ffc23320: 41 9e 03 28 beq- cr7,ffc23648 <rtems_rfs_dir_lookup_ino+0x594><== NEVER TAKEN
{
uint8_t* entry;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
ffc23324: 38 60 00 00 li r3,0
ffc23328: 3c 80 04 00 lis r4,1024
ffc2332c: 4b ff 46 3d bl ffc17968 <rtems_rfs_trace>
ffc23330: 2f 83 00 00 cmpwi cr7,r3,0
ffc23334: 40 9e 02 40 bne- cr7,ffc23574 <rtems_rfs_dir_lookup_ino+0x4c0><== NEVER TAKEN
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno);
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
ffc23338: 80 a1 00 08 lwz r5,8(r1)
ffc2333c: 7f a3 eb 78 mr r3,r29
ffc23340: 38 81 00 0c addi r4,r1,12
ffc23344: 38 c0 00 01 li r6,1
ffc23348: 4b ff f5 0d bl ffc22854 <rtems_rfs_buffer_handle_request>
if (rc > 0)
ffc2334c: 2e 03 00 00 cmpwi cr4,r3,0
ffc23350: 7c 75 1b 78 mr r21,r3
ffc23354: 41 91 02 ac bgt- cr4,ffc23600 <rtems_rfs_dir_lookup_ino+0x54c><== NEVER TAKEN
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
ffc23358: 81 1d 00 08 lwz r8,8(r29)
/*
* Search the block to see if the name matches. A hash of 0xffff or 0x0
* means the entry is empty.
*/
entry = rtems_rfs_buffer_data (&entries);
ffc2335c: 81 21 00 14 lwz r9,20(r1)
map.bpos.boff = 0;
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
ffc23360: 2f 88 00 0a cmpwi cr7,r8,10
* means the entry is empty.
*/
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
ffc23364: 92 61 00 2c stw r19,44(r1)
/*
* Search the block to see if the name matches. A hash of 0xffff or 0x0
* means the entry is empty.
*/
entry = rtems_rfs_buffer_data (&entries);
ffc23368: 83 e9 00 24 lwz r31,36(r9)
map.bpos.boff = 0;
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
ffc2336c: 40 be 00 24 bne+ cr7,ffc23390 <rtems_rfs_dir_lookup_ino+0x2dc><== ALWAYS TAKEN
ffc23370: 48 00 01 08 b ffc23478 <rtems_rfs_dir_lookup_ino+0x3c4><== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
ffc23374: 80 01 00 2c lwz r0,44(r1)
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
ffc23378: 39 28 ff f6 addi r9,r8,-10
return 0;
}
}
map.bpos.boff += elength;
entry += elength;
ffc2337c: 7f ff f2 14 add r31,r31,r30
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
ffc23380: 7c 1e 02 14 add r0,r30,r0
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
ffc23384: 7f 89 00 40 cmplw cr7,r9,r0
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
ffc23388: 90 01 00 2c stw r0,44(r1)
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
ffc2338c: 40 9d 00 ec ble- cr7,ffc23478 <rtems_rfs_dir_lookup_ino+0x3c4><== NEVER TAKEN
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
ffc23390: 8b df 00 08 lbz r30,8(r31)
ffc23394: 89 3f 00 09 lbz r9,9(r31)
ffc23398: 57 de 40 2e rlwinm r30,r30,8,0,23
*ino = rtems_rfs_dir_entry_ino (entry);
ffc2339c: 89 5f 00 00 lbz r10,0(r31)
ffc233a0: 88 1f 00 01 lbz r0,1(r31)
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
ffc233a4: 7f de 4b 78 or r30,r30,r9
*ino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc233a8: 7f 9e d8 00 cmpw cr7,r30,r27
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
ffc233ac: 89 7f 00 03 lbz r11,3(r31)
ffc233b0: 89 3f 00 02 lbz r9,2(r31)
ffc233b4: 55 4a c0 0e rlwinm r10,r10,24,0,7
ffc233b8: 54 00 80 1e rlwinm r0,r0,16,0,15
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
ffc233bc: 88 df 00 04 lbz r6,4(r31)
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
ffc233c0: 7d 40 03 78 or r0,r10,r0
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
ffc233c4: 88 ff 00 05 lbz r7,5(r31)
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
ffc233c8: 7c 00 5b 78 or r0,r0,r11
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
ffc233cc: 89 5f 00 07 lbz r10,7(r31)
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
ffc233d0: 55 29 40 2e rlwinm r9,r9,8,0,23
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
ffc233d4: 89 7f 00 06 lbz r11,6(r31)
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
ffc233d8: 7c 00 4b 78 or r0,r0,r9
ffc233dc: 90 1c 00 00 stw r0,0(r28)
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc233e0: 41 9e 00 98 beq- cr7,ffc23478 <rtems_rfs_dir_lookup_ino+0x3c4>
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
ffc233e4: 2f 9e 00 0a cmpwi cr7,r30,10
ffc233e8: 40 9d 00 9c ble- cr7,ffc23484 <rtems_rfs_dir_lookup_ino+0x3d0>
ffc233ec: 81 3d 00 18 lwz r9,24(r29)
ffc233f0: 7f 9e 48 40 cmplw cr7,r30,r9
ffc233f4: 40 9c 00 90 bge- cr7,ffc23484 <rtems_rfs_dir_lookup_ino+0x3d0><== NEVER TAKEN
ffc233f8: 2f 80 00 00 cmpwi cr7,r0,0
ffc233fc: 41 9e 00 88 beq- cr7,ffc23484 <rtems_rfs_dir_lookup_ino+0x3d0><== NEVER TAKEN
ffc23400: 81 3d 00 10 lwz r9,16(r29)
ffc23404: 7f 80 48 40 cmplw cr7,r0,r9
ffc23408: 41 9d 00 7c bgt- cr7,ffc23484 <rtems_rfs_dir_lookup_ino+0x3d0><== NEVER TAKEN
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
ffc2340c: 54 c6 c0 0e rlwinm r6,r6,24,0,7
ffc23410: 54 e7 80 1e rlwinm r7,r7,16,0,15
ffc23414: 7c c7 3b 78 or r7,r6,r7
ffc23418: 7c ea 53 78 or r10,r7,r10
ffc2341c: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc23420: 7d 4b 5b 78 or r11,r10,r11
rtems_rfs_inode_ino (inode), elength, *ino, map.bpos.boff);
rc = EIO;
break;
}
if (ehash == hash)
ffc23424: 7f 8b d0 00 cmpw cr7,r11,r26
ffc23428: 40 9e ff 4c bne+ cr7,ffc23374 <rtems_rfs_dir_lookup_ino+0x2c0>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
ffc2342c: 38 60 00 00 li r3,0
ffc23430: 3c 80 08 00 lis r4,2048
ffc23434: 4b ff 45 35 bl ffc17968 <rtems_rfs_trace>
ffc23438: 2f 83 00 00 cmpwi cr7,r3,0
ffc2343c: 40 9e 00 f0 bne- cr7,ffc2352c <rtems_rfs_dir_lookup_ino+0x478><== NEVER TAKEN
"checking entry for ino %" PRId32 ": bno=%04" PRIx32 "/off=%04" PRIx32
" length:%d ino:%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0)
ffc23440: 38 7f 00 0a addi r3,r31,10
ffc23444: 7f 04 c3 78 mr r4,r24
ffc23448: 7f 25 cb 78 mr r5,r25
ffc2344c: 48 00 74 ad bl ffc2a8f8 <memcmp>
ffc23450: 2f 83 00 00 cmpwi cr7,r3,0
ffc23454: 41 9e 01 68 beq- cr7,ffc235bc <rtems_rfs_dir_lookup_ino+0x508><== ALWAYS TAKEN
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
ffc23458: 80 01 00 2c lwz r0,44(r1) <== NOT EXECUTED
entry += elength;
ffc2345c: 7f ff f2 14 add r31,r31,r30 <== NOT EXECUTED
ffc23460: 81 1d 00 08 lwz r8,8(r29) <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
ffc23464: 7c 1e 02 14 add r0,r30,r0 <== NOT EXECUTED
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
ffc23468: 39 28 ff f6 addi r9,r8,-10 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
ffc2346c: 90 01 00 2c stw r0,44(r1) <== NOT EXECUTED
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
ffc23470: 7f 89 00 40 cmplw cr7,r9,r0 <== NOT EXECUTED
ffc23474: 41 9d ff 1c bgt+ cr7,ffc23390 <rtems_rfs_dir_lookup_ino+0x2dc><== NOT EXECUTED
map.bpos.boff += elength;
entry += elength;
}
if (rc == 0)
ffc23478: 41 92 00 54 beq- cr4,ffc234cc <rtems_rfs_dir_lookup_ino+0x418><== ALWAYS TAKEN
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
ffc2347c: 7e b6 ab 78 mr r22,r21
ffc23480: 4b ff fe 14 b ffc23294 <rtems_rfs_dir_lookup_ino+0x1e0>
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
ffc23484: 38 60 00 00 li r3,0
ffc23488: 3c 80 04 00 lis r4,1024
ffc2348c: 4b ff 44 dd bl ffc17968 <rtems_rfs_trace>
ffc23490: 2f 83 00 00 cmpwi cr7,r3,0
ffc23494: 40 9e 00 10 bne- cr7,ffc234a4 <rtems_rfs_dir_lookup_ino+0x3f0><== NEVER TAKEN
printf ("rtems-rfs: dir-lookup-ino: "
"block map next block failed in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
if (rc == ENXIO)
rc = ENOENT;
ffc23498: 3a a0 00 05 li r21,5
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
ffc2349c: 7e b6 ab 78 mr r22,r21
ffc234a0: 4b ff fd f4 b ffc23294 <rtems_rfs_dir_lookup_ino+0x1e0>
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: "
ffc234a4: 80 97 00 08 lwz r4,8(r23) <== NOT EXECUTED
ffc234a8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc234ac: 80 dc 00 00 lwz r6,0(r28) <== NOT EXECUTED
ffc234b0: 38 63 ce 24 addi r3,r3,-12764 <== NOT EXECUTED
ffc234b4: 80 e1 00 2c lwz r7,44(r1) <== NOT EXECUTED
ffc234b8: 7f c5 f3 78 mr r5,r30 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
"block map next block failed in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
if (rc == ENXIO)
rc = ENOENT;
ffc234bc: 3a a0 00 05 li r21,5 <== NOT EXECUTED
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: "
ffc234c0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc234c4: 48 00 78 81 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc234c8: 4b ff ff d4 b ffc2349c <rtems_rfs_dir_lookup_ino+0x3e8><== NOT EXECUTED
entry += elength;
}
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
ffc234cc: 7f a3 eb 78 mr r3,r29
ffc234d0: 38 81 00 18 addi r4,r1,24
ffc234d4: 38 a1 00 08 addi r5,r1,8
ffc234d8: 4b ff e7 09 bl ffc21be0 <rtems_rfs_block_map_next_block>
if ((rc > 0) && (rc != ENXIO))
ffc234dc: 2e 03 00 00 cmpwi cr4,r3,0
ffc234e0: 7c 76 1b 78 mr r22,r3
ffc234e4: 40 b1 fe 30 ble- cr4,ffc23314 <rtems_rfs_dir_lookup_ino+0x260><== NEVER TAKEN
ffc234e8: 2f 83 00 06 cmpwi cr7,r3,6
ffc234ec: 41 9e 00 a0 beq- cr7,ffc2358c <rtems_rfs_dir_lookup_ino+0x4d8><== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
ffc234f0: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc234f4: 3c 80 04 00 lis r4,1024 <== NOT EXECUTED
ffc234f8: 4b ff 44 71 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc234fc: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc23500: 41 9e fe 14 beq+ cr7,ffc23314 <rtems_rfs_dir_lookup_ino+0x260><== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
ffc23504: 83 f7 00 08 lwz r31,8(r23) <== NOT EXECUTED
ffc23508: 7e c3 b3 78 mr r3,r22 <== NOT EXECUTED
ffc2350c: 48 00 85 a5 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc23510: 7e c5 b3 78 mr r5,r22 <== NOT EXECUTED
ffc23514: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc23518: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc2351c: 7e 03 83 78 mr r3,r16 <== NOT EXECUTED
ffc23520: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc23524: 48 00 78 21 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc23528: 4b ff fd ec b ffc23314 <rtems_rfs_dir_lookup_ino+0x260><== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
"checking entry for ino %" PRId32 ": bno=%04" PRIx32 "/off=%04" PRIx32
" length:%d ino:%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
ffc2352c: 89 1f 00 00 lbz r8,0(r31) <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
ffc23530: 7e 43 93 78 mr r3,r18 <== NOT EXECUTED
"checking entry for ino %" PRId32 ": bno=%04" PRIx32 "/off=%04" PRIx32
" length:%d ino:%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
ffc23534: 89 7f 00 01 lbz r11,1(r31) <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
ffc23538: 7f c7 f3 78 mr r7,r30 <== NOT EXECUTED
"checking entry for ino %" PRId32 ": bno=%04" PRIx32 "/off=%04" PRIx32
" length:%d ino:%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
ffc2353c: 89 3f 00 03 lbz r9,3(r31) <== NOT EXECUTED
ffc23540: 55 08 c0 0e rlwinm r8,r8,24,0,7 <== NOT EXECUTED
ffc23544: 55 6b 80 1e rlwinm r11,r11,16,0,15 <== NOT EXECUTED
ffc23548: 88 1f 00 02 lbz r0,2(r31) <== NOT EXECUTED
ffc2354c: 7d 08 5b 78 or r8,r8,r11 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
ffc23550: 80 97 00 08 lwz r4,8(r23) <== NOT EXECUTED
"checking entry for ino %" PRId32 ": bno=%04" PRIx32 "/off=%04" PRIx32
" length:%d ino:%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
ffc23554: 7d 08 4b 78 or r8,r8,r9 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
ffc23558: 80 a1 00 28 lwz r5,40(r1) <== NOT EXECUTED
"checking entry for ino %" PRId32 ": bno=%04" PRIx32 "/off=%04" PRIx32
" length:%d ino:%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
ffc2355c: 54 00 40 2e rlwinm r0,r0,8,0,23 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
ffc23560: 80 c1 00 2c lwz r6,44(r1) <== NOT EXECUTED
ffc23564: 7d 08 03 78 or r8,r8,r0 <== NOT EXECUTED
ffc23568: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc2356c: 48 00 77 d9 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc23570: 4b ff fe d0 b ffc23440 <rtems_rfs_dir_lookup_ino+0x38c><== NOT EXECUTED
while ((rc == 0) && block)
{
uint8_t* entry;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
ffc23574: 80 97 00 08 lwz r4,8(r23) <== NOT EXECUTED
ffc23578: 7e 23 8b 78 mr r3,r17 <== NOT EXECUTED
ffc2357c: 80 a1 00 28 lwz r5,40(r1) <== NOT EXECUTED
ffc23580: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc23584: 48 00 77 c1 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc23588: 4b ff fd b0 b ffc23338 <rtems_rfs_dir_lookup_ino+0x284><== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
"block map next block failed in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
if (rc == ENXIO)
rc = ENOENT;
ffc2358c: 3a c0 00 02 li r22,2
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
ffc23590: 7e d5 b3 78 mr r21,r22
ffc23594: 4b ff fe e8 b ffc2347c <rtems_rfs_dir_lookup_ino+0x3c8>
*/
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
ffc23598: 7e c3 b3 78 mr r3,r22 <== NOT EXECUTED
ffc2359c: 48 00 85 15 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc235a0: 7e c4 b3 78 mr r4,r22 <== NOT EXECUTED
ffc235a4: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc235a8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc235ac: 38 63 cd 6c addi r3,r3,-12948 <== NOT EXECUTED
ffc235b0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc235b4: 48 00 77 91 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc235b8: 4b ff fc d0 b ffc23288 <rtems_rfs_dir_lookup_ino+0x1d4><== NOT EXECUTED
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0)
{
*offset = rtems_rfs_block_map_pos (fs, &map);
ffc235bc: 7f a3 eb 78 mr r3,r29
ffc235c0: 38 81 00 28 addi r4,r1,40
ffc235c4: 4b ff de 71 bl ffc21434 <rtems_rfs_block_get_pos>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
ffc235c8: 38 60 00 00 li r3,0
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0)
{
*offset = rtems_rfs_block_map_pos (fs, &map);
ffc235cc: 90 94 00 00 stw r4,0(r20)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
ffc235d0: 3c 80 10 00 lis r4,4096
ffc235d4: 4b ff 43 95 bl ffc17968 <rtems_rfs_trace>
ffc235d8: 2f 83 00 00 cmpwi cr7,r3,0
ffc235dc: 41 9e fc b8 beq+ cr7,ffc23294 <rtems_rfs_dir_lookup_ino+0x1e0><== ALWAYS TAKEN
printf ("rtems-rfs: dir-lookup-ino: "
ffc235e0: 80 97 00 08 lwz r4,8(r23) <== NOT EXECUTED
ffc235e4: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc235e8: 80 bc 00 00 lwz r5,0(r28) <== NOT EXECUTED
ffc235ec: 38 63 ce d0 addi r3,r3,-12592 <== NOT EXECUTED
ffc235f0: 80 d4 00 00 lwz r6,0(r20) <== NOT EXECUTED
ffc235f4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc235f8: 48 00 77 4d bl ffc2ad44 <printf> <== NOT EXECUTED
ffc235fc: 4b ff fc 98 b ffc23294 <rtems_rfs_dir_lookup_ino+0x1e0><== NOT EXECUTED
rtems_rfs_inode_ino (inode), map.bpos.bno);
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
ffc23600: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc23604: 3c 80 04 00 lis r4,1024 <== NOT EXECUTED
ffc23608: 4b ff 43 61 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc2360c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc23610: 41 9e fe 6c beq+ cr7,ffc2347c <rtems_rfs_dir_lookup_ino+0x3c8><== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " block=%" PRId32 ": %d: %s\n",
ffc23614: 7e a3 ab 78 mr r3,r21 <== NOT EXECUTED
ffc23618: 83 d7 00 08 lwz r30,8(r23) <== NOT EXECUTED
ffc2361c: 83 e1 00 08 lwz r31,8(r1) <== NOT EXECUTED
ffc23620: 48 00 84 91 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc23624: 7c 67 1b 78 mr r7,r3 <== NOT EXECUTED
ffc23628: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc2362c: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc23630: 7f e5 fb 78 mr r5,r31 <== NOT EXECUTED
ffc23634: 7e a6 ab 78 mr r6,r21 <== NOT EXECUTED
ffc23638: 38 63 cd e0 addi r3,r3,-12832 <== NOT EXECUTED
ffc2363c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc23640: 48 00 77 05 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc23644: 4b ff fe 38 b ffc2347c <rtems_rfs_dir_lookup_ino+0x3c8><== NOT EXECUTED
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
ffc23648: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc2364c: 3c 80 04 00 lis r4,1024 <== NOT EXECUTED
ffc23650: 4b ff 43 19 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc23654: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc23658: 40 9e 00 0c bne- cr7,ffc23664 <rtems_rfs_dir_lookup_ino+0x5b0><== NOT EXECUTED
}
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
ffc2365c: 3a c0 00 05 li r22,5 <== NOT EXECUTED
ffc23660: 4b ff fc 34 b ffc23294 <rtems_rfs_dir_lookup_ino+0x1e0><== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
ffc23664: 38 60 00 05 li r3,5 <== NOT EXECUTED
ffc23668: 83 f7 00 08 lwz r31,8(r23) <== NOT EXECUTED
ffc2366c: 48 00 84 45 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc23670: 38 a0 00 05 li r5,5 <== NOT EXECUTED
ffc23674: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc23678: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc2367c: 38 63 cf 64 addi r3,r3,-12444 <== NOT EXECUTED
ffc23680: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc23684: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc23688: 48 00 76 bd bl ffc2ad44 <printf> <== NOT EXECUTED
}
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
ffc2368c: 3a c0 00 05 li r22,5 <== NOT EXECUTED
ffc23690: 4b ff fc 04 b ffc23294 <rtems_rfs_dir_lookup_ino+0x1e0><== NOT EXECUTED
ffc24040 <rtems_rfs_dir_read>:
rtems_rfs_dir_read (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_pos_rel offset,
struct dirent* dirent,
size_t* length)
{
ffc24040: 94 21 ff 60 stwu r1,-160(r1) <== NOT EXECUTED
ffc24044: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc24048: 93 61 00 8c stw r27,140(r1) <== NOT EXECUTED
ffc2404c: 7c 9b 23 78 mr r27,r4 <== NOT EXECUTED
rtems_rfs_block_map map;
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
ffc24050: 3c 80 80 00 lis r4,-32768 <== NOT EXECUTED
rtems_rfs_dir_read (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_pos_rel offset,
struct dirent* dirent,
size_t* length)
{
ffc24054: 93 81 00 90 stw r28,144(r1) <== NOT EXECUTED
ffc24058: 7c 7c 1b 78 mr r28,r3 <== NOT EXECUTED
rtems_rfs_block_map map;
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
ffc2405c: 38 60 00 00 li r3,0 <== NOT EXECUTED
rtems_rfs_dir_read (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_pos_rel offset,
struct dirent* dirent,
size_t* length)
{
ffc24060: 92 e1 00 7c stw r23,124(r1) <== NOT EXECUTED
ffc24064: 7d 17 43 78 mr r23,r8 <== NOT EXECUTED
ffc24068: 93 41 00 88 stw r26,136(r1) <== NOT EXECUTED
ffc2406c: 7c fa 3b 78 mr r26,r7 <== NOT EXECUTED
ffc24070: 93 c1 00 98 stw r30,152(r1) <== NOT EXECUTED
ffc24074: 7c be 2b 78 mr r30,r5 <== NOT EXECUTED
ffc24078: 93 e1 00 9c stw r31,156(r1) <== NOT EXECUTED
ffc2407c: 7c df 33 78 mr r31,r6 <== NOT EXECUTED
ffc24080: 90 01 00 a4 stw r0,164(r1) <== NOT EXECUTED
ffc24084: 92 61 00 6c stw r19,108(r1) <== NOT EXECUTED
ffc24088: 92 81 00 70 stw r20,112(r1) <== NOT EXECUTED
ffc2408c: 92 a1 00 74 stw r21,116(r1) <== NOT EXECUTED
ffc24090: 92 c1 00 78 stw r22,120(r1) <== NOT EXECUTED
ffc24094: 93 01 00 80 stw r24,128(r1) <== NOT EXECUTED
ffc24098: 93 21 00 84 stw r25,132(r1) <== NOT EXECUTED
ffc2409c: 93 a1 00 94 stw r29,148(r1) <== NOT EXECUTED
rtems_rfs_block_map map;
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
ffc240a0: 4b ff 38 c9 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc240a4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc240a8: 40 9e 00 d0 bne- cr7,ffc24178 <rtems_rfs_dir_read+0x138><== NOT EXECUTED
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
rtems_rfs_inode_ino (dir), offset);
*length = 0;
ffc240ac: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc240b0: 90 17 00 00 stw r0,0(r23) <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
ffc240b4: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc240b8: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc240bc: 38 a1 00 18 addi r5,r1,24 <== NOT EXECUTED
ffc240c0: 4b ff d4 99 bl ffc21558 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
ffc240c4: 7c 7d 1b 79 mr. r29,r3 <== NOT EXECUTED
ffc240c8: 40 81 00 4c ble- ffc24114 <rtems_rfs_dir_read+0xd4> <== NOT EXECUTED
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
ffc240cc: 80 01 00 a4 lwz r0,164(r1) <== NOT EXECUTED
ffc240d0: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc240d4: 82 61 00 6c lwz r19,108(r1) <== NOT EXECUTED
ffc240d8: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc240dc: 82 81 00 70 lwz r20,112(r1) <== NOT EXECUTED
ffc240e0: 82 a1 00 74 lwz r21,116(r1) <== NOT EXECUTED
ffc240e4: 82 c1 00 78 lwz r22,120(r1) <== NOT EXECUTED
ffc240e8: 82 e1 00 7c lwz r23,124(r1) <== NOT EXECUTED
ffc240ec: 83 01 00 80 lwz r24,128(r1) <== NOT EXECUTED
ffc240f0: 83 21 00 84 lwz r25,132(r1) <== NOT EXECUTED
ffc240f4: 83 41 00 88 lwz r26,136(r1) <== NOT EXECUTED
ffc240f8: 83 61 00 8c lwz r27,140(r1) <== NOT EXECUTED
ffc240fc: 83 81 00 90 lwz r28,144(r1) <== NOT EXECUTED
ffc24100: 83 a1 00 94 lwz r29,148(r1) <== NOT EXECUTED
ffc24104: 83 c1 00 98 lwz r30,152(r1) <== NOT EXECUTED
ffc24108: 83 e1 00 9c lwz r31,156(r1) <== NOT EXECUTED
ffc2410c: 38 21 00 a0 addi r1,r1,160 <== NOT EXECUTED
ffc24110: 4e 80 00 20 blr <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
if (rc > 0)
return rc;
if (((rtems_rfs_fs_block_size (fs) -
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
ffc24114: 83 3c 00 08 lwz r25,8(r28) <== NOT EXECUTED
ffc24118: 3b 00 00 00 li r24,0 <== NOT EXECUTED
ffc2411c: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc24120: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc24124: 7f 05 c3 78 mr r5,r24 <== NOT EXECUTED
ffc24128: 7f 26 cb 78 mr r6,r25 <== NOT EXECUTED
ffc2412c: 48 01 3d 49 bl ffc37e74 <__moddi3> <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
if (rc > 0)
return rc;
if (((rtems_rfs_fs_block_size (fs) -
ffc24130: 7d 64 c8 10 subfc r11,r4,r25 <== NOT EXECUTED
ffc24134: 7d 43 c1 10 subfe r10,r3,r24 <== NOT EXECUTED
ffc24138: 2f 8a 00 00 cmpwi cr7,r10,0 <== NOT EXECUTED
ffc2413c: 40 9d 00 5c ble- cr7,ffc24198 <rtems_rfs_dir_read+0x158><== NOT EXECUTED
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
rtems_rfs_fs_block_size (fs));
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
ffc24140: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc24144: 38 81 00 18 addi r4,r1,24 <== NOT EXECUTED
ffc24148: 7f c5 f3 78 mr r5,r30 <== NOT EXECUTED
ffc2414c: 7f e6 fb 78 mr r6,r31 <== NOT EXECUTED
ffc24150: 38 e1 00 08 addi r7,r1,8 <== NOT EXECUTED
ffc24154: 4b ff d9 c9 bl ffc21b1c <rtems_rfs_block_map_seek> <== NOT EXECUTED
if (rc > 0)
ffc24158: 7c 7d 1b 79 mr. r29,r3 <== NOT EXECUTED
ffc2415c: 40 81 00 94 ble- ffc241f0 <rtems_rfs_dir_read+0x1b0> <== NOT EXECUTED
{
if (rc == ENXIO)
ffc24160: 2f 9d 00 06 cmpwi cr7,r29,6 <== NOT EXECUTED
ffc24164: 41 9e 00 78 beq- cr7,ffc241dc <rtems_rfs_dir_read+0x19c><== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
ffc24168: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc2416c: 38 81 00 18 addi r4,r1,24 <== NOT EXECUTED
ffc24170: 4b ff d5 f1 bl ffc21760 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
ffc24174: 4b ff ff 58 b ffc240cc <rtems_rfs_dir_read+0x8c> <== NOT EXECUTED
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
ffc24178: 80 9b 00 08 lwz r4,8(r27) <== NOT EXECUTED
ffc2417c: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc24180: 7f c5 f3 78 mr r5,r30 <== NOT EXECUTED
ffc24184: 7f e6 fb 78 mr r6,r31 <== NOT EXECUTED
ffc24188: 38 63 d2 70 addi r3,r3,-11664 <== NOT EXECUTED
ffc2418c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc24190: 48 00 6b b5 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc24194: 4b ff ff 18 b ffc240ac <rtems_rfs_dir_read+0x6c> <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
if (rc > 0)
return rc;
if (((rtems_rfs_fs_block_size (fs) -
ffc24198: 40 9e 00 0c bne- cr7,ffc241a4 <rtems_rfs_dir_read+0x164><== NOT EXECUTED
ffc2419c: 2b 8b 00 0a cmplwi cr7,r11,10 <== NOT EXECUTED
ffc241a0: 41 bd ff a0 bgt- cr7,ffc24140 <rtems_rfs_dir_read+0x100><== NOT EXECUTED
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
ffc241a4: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc241a8: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc241ac: 7f 05 c3 78 mr r5,r24 <== NOT EXECUTED
ffc241b0: 7f 26 cb 78 mr r6,r25 <== NOT EXECUTED
ffc241b4: 48 01 38 81 bl ffc37a34 <__divdi3> <== NOT EXECUTED
ffc241b8: 31 64 00 01 addic r11,r4,1 <== NOT EXECUTED
ffc241bc: 7d 43 01 94 addze r10,r3 <== NOT EXECUTED
ffc241c0: 7d 38 59 d6 mullw r9,r24,r11 <== NOT EXECUTED
ffc241c4: 7c 0a c9 d6 mullw r0,r10,r25 <== NOT EXECUTED
ffc241c8: 7f d9 58 16 mulhwu r30,r25,r11 <== NOT EXECUTED
ffc241cc: 7c 09 02 14 add r0,r9,r0 <== NOT EXECUTED
ffc241d0: 7f f9 59 d6 mullw r31,r25,r11 <== NOT EXECUTED
ffc241d4: 7f c0 f2 14 add r30,r0,r30 <== NOT EXECUTED
ffc241d8: 4b ff ff 68 b ffc24140 <rtems_rfs_dir_read+0x100> <== NOT EXECUTED
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
if (rc > 0)
{
if (rc == ENXIO)
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
ffc241dc: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc241e0: 38 81 00 18 addi r4,r1,24 <== NOT EXECUTED
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
if (rc > 0)
{
if (rc == ENXIO)
rc = ENOENT;
ffc241e4: 3b a0 00 02 li r29,2 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
ffc241e8: 4b ff d5 79 bl ffc21760 <rtems_rfs_block_map_close> <== NOT EXECUTED
ffc241ec: 4b ff fe e0 b ffc240cc <rtems_rfs_dir_read+0x8c> <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
handle->bnum = 0;
ffc241f0: 38 00 00 00 li r0,0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc241f4: 39 20 00 00 li r9,0 <== NOT EXECUTED
handle->bnum = 0;
ffc241f8: 90 01 00 10 stw r0,16(r1) <== NOT EXECUTED
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc241fc: 3b 00 00 00 li r24,0 <== NOT EXECUTED
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
ffc24200: 3f 20 ff c4 lis r25,-60 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc24204: 99 21 00 0c stb r9,12(r1) <== NOT EXECUTED
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc24208: 63 18 ff ff ori r24,r24,65535 <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
ffc2420c: 90 01 00 14 stw r0,20(r1) <== NOT EXECUTED
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
ffc24210: 3b 39 d3 18 addi r25,r25,-11496 <== NOT EXECUTED
uint8_t* entry;
rtems_rfs_ino eino;
int elength;
int remaining;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
ffc24214: 80 a1 00 08 lwz r5,8(r1) <== NOT EXECUTED
ffc24218: 38 81 00 0c addi r4,r1,12 <== NOT EXECUTED
ffc2421c: 38 c0 00 01 li r6,1 <== NOT EXECUTED
ffc24220: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc24224: 4b ff e6 31 bl ffc22854 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
break;
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
ffc24228: 3c 80 80 00 lis r4,-32768 <== NOT EXECUTED
rtems_rfs_ino eino;
int elength;
int remaining;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
ffc2422c: 7c 7d 1b 79 mr. r29,r3 <== NOT EXECUTED
break;
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
ffc24230: 38 60 00 00 li r3,0 <== NOT EXECUTED
rtems_rfs_ino eino;
int elength;
int remaining;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
ffc24234: 41 81 00 d8 bgt- ffc2430c <rtems_rfs_dir_read+0x2cc> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
entry = rtems_rfs_buffer_data (&buffer);
ffc24238: 81 21 00 14 lwz r9,20(r1) <== NOT EXECUTED
entry += map.bpos.boff;
ffc2423c: 82 61 00 2c lwz r19,44(r1) <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
entry = rtems_rfs_buffer_data (&buffer);
ffc24240: 81 29 00 24 lwz r9,36(r9) <== NOT EXECUTED
entry += map.bpos.boff;
ffc24244: 7e 89 9a 14 add r20,r9,r19 <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
ffc24248: 7e a9 98 ae lbzx r21,r9,r19 <== NOT EXECUTED
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
ffc2424c: 8a d4 00 08 lbz r22,8(r20) <== NOT EXECUTED
ffc24250: 88 14 00 09 lbz r0,9(r20) <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
ffc24254: 56 b5 c0 0e rlwinm r21,r21,24,0,7 <== NOT EXECUTED
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
ffc24258: 56 d6 40 2e rlwinm r22,r22,8,0,23 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
ffc2425c: 89 74 00 01 lbz r11,1(r20) <== NOT EXECUTED
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
ffc24260: 7e d6 03 78 or r22,r22,r0 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
ffc24264: 89 34 00 03 lbz r9,3(r20) <== NOT EXECUTED
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc24268: 7f 96 c0 00 cmpw cr7,r22,r24 <== NOT EXECUTED
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
ffc2426c: 88 14 00 02 lbz r0,2(r20) <== NOT EXECUTED
ffc24270: 55 6b 80 1e rlwinm r11,r11,16,0,15 <== NOT EXECUTED
ffc24274: 7e b5 5b 78 or r21,r21,r11 <== NOT EXECUTED
ffc24278: 7e b5 4b 78 or r21,r21,r9 <== NOT EXECUTED
ffc2427c: 54 00 40 2e rlwinm r0,r0,8,0,23 <== NOT EXECUTED
ffc24280: 7e b5 03 78 or r21,r21,r0 <== NOT EXECUTED
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc24284: 40 9e 00 b8 bne- cr7,ffc2433c <rtems_rfs_dir_read+0x2fc><== NOT EXECUTED
printf ("rtems-rfs: dir-read: found off:%" PRIdoff_t " ino:%ld name=%s\n",
dirent->d_off, dirent->d_ino, dirent->d_name);
break;
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
ffc24288: 81 3c 00 08 lwz r9,8(r28) <== NOT EXECUTED
ffc2428c: 80 17 00 00 lwz r0,0(r23) <== NOT EXECUTED
ffc24290: 7e 73 48 50 subf r19,r19,r9 <== NOT EXECUTED
ffc24294: 7e 60 9a 14 add r19,r0,r19 <== NOT EXECUTED
ffc24298: 92 77 00 00 stw r19,0(r23) <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
ffc2429c: 4b ff 36 cd bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc242a0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc242a4: 40 9e 00 2c bne- cr7,ffc242d0 <rtems_rfs_dir_read+0x290><== NOT EXECUTED
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
ffc242a8: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc242ac: 38 81 00 18 addi r4,r1,24 <== NOT EXECUTED
ffc242b0: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
ffc242b4: 4b ff d9 2d bl ffc21be0 <rtems_rfs_block_map_next_block><== NOT EXECUTED
if (rc == ENXIO)
ffc242b8: 2f 83 00 06 cmpwi cr7,r3,6 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
ffc242bc: 7c 7d 1b 78 mr r29,r3 <== NOT EXECUTED
/*
* Look for an empty entry and if this is the last block that is the end of
* the directory.
*/
while (rc == 0)
ffc242c0: 2f 03 00 00 cmpwi cr6,r3,0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc == ENXIO)
ffc242c4: 41 9e 00 44 beq- cr7,ffc24308 <rtems_rfs_dir_read+0x2c8><== NOT EXECUTED
/*
* Look for an empty entry and if this is the last block that is the end of
* the directory.
*/
while (rc == 0)
ffc242c8: 41 9a ff 4c beq+ cr6,ffc24214 <rtems_rfs_dir_read+0x1d4><== NOT EXECUTED
ffc242cc: 48 00 00 40 b ffc2430c <rtems_rfs_dir_read+0x2cc> <== NOT EXECUTED
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
ffc242d0: 80 f7 00 00 lwz r7,0(r23) <== NOT EXECUTED
ffc242d4: 7f c5 f3 78 mr r5,r30 <== NOT EXECUTED
ffc242d8: 7f e6 fb 78 mr r6,r31 <== NOT EXECUTED
ffc242dc: 7f 23 cb 78 mr r3,r25 <== NOT EXECUTED
ffc242e0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc242e4: 48 00 6a 61 bl ffc2ad44 <printf> <== NOT EXECUTED
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
ffc242e8: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc242ec: 38 81 00 18 addi r4,r1,24 <== NOT EXECUTED
ffc242f0: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
ffc242f4: 4b ff d8 ed bl ffc21be0 <rtems_rfs_block_map_next_block><== NOT EXECUTED
if (rc == ENXIO)
ffc242f8: 2f 83 00 06 cmpwi cr7,r3,6 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
ffc242fc: 7c 7d 1b 78 mr r29,r3 <== NOT EXECUTED
/*
* Look for an empty entry and if this is the last block that is the end of
* the directory.
*/
while (rc == 0)
ffc24300: 2f 03 00 00 cmpwi cr6,r3,0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc == ENXIO)
ffc24304: 40 9e ff c4 bne+ cr7,ffc242c8 <rtems_rfs_dir_read+0x288><== NOT EXECUTED
rc = ENOENT;
ffc24308: 3b a0 00 02 li r29,2 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc2430c: 38 81 00 0c addi r4,r1,12 <== NOT EXECUTED
ffc24310: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc24314: 4b ff e3 2d bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
ffc24318: 38 00 00 00 li r0,0 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc2431c: 39 20 00 00 li r9,0 <== NOT EXECUTED
handle->bnum = 0;
ffc24320: 90 01 00 10 stw r0,16(r1) <== NOT EXECUTED
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
ffc24324: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc24328: 38 81 00 18 addi r4,r1,24 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc2432c: 99 21 00 0c stb r9,12(r1) <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
ffc24330: 90 01 00 14 stw r0,20(r1) <== NOT EXECUTED
ffc24334: 4b ff d4 2d bl ffc21760 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
ffc24338: 4b ff fd 94 b ffc240cc <rtems_rfs_dir_read+0x8c> <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
ffc2433c: 2f 96 00 0a cmpwi cr7,r22,10 <== NOT EXECUTED
ffc24340: 40 9d 00 24 ble- cr7,ffc24364 <rtems_rfs_dir_read+0x324><== NOT EXECUTED
ffc24344: 80 1c 00 18 lwz r0,24(r28) <== NOT EXECUTED
ffc24348: 7f 96 00 40 cmplw cr7,r22,r0 <== NOT EXECUTED
ffc2434c: 40 9c 00 18 bge- cr7,ffc24364 <rtems_rfs_dir_read+0x324><== NOT EXECUTED
ffc24350: 2f 95 00 00 cmpwi cr7,r21,0 <== NOT EXECUTED
ffc24354: 41 9e 00 10 beq- cr7,ffc24364 <rtems_rfs_dir_read+0x324><== NOT EXECUTED
ffc24358: 80 1c 00 10 lwz r0,16(r28) <== NOT EXECUTED
ffc2435c: 7f 80 a8 40 cmplw cr7,r0,r21 <== NOT EXECUTED
ffc24360: 40 9c 00 40 bge- cr7,ffc243a0 <rtems_rfs_dir_read+0x360><== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
ffc24364: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc24368: 3c 80 80 00 lis r4,-32768 <== NOT EXECUTED
ffc2436c: 4b ff 35 fd bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
printf ("rtems-rfs: dir-read: "
"bad length or ino for ino %" PRIu32 ": %u/%" PRId32 " @ %04" PRIx32 "\n",
rtems_rfs_inode_ino (dir), elength, eino, map.bpos.boff);
rc = EIO;
ffc24370: 3b a0 00 05 li r29,5 <== NOT EXECUTED
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
ffc24374: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc24378: 41 9e ff 94 beq+ cr7,ffc2430c <rtems_rfs_dir_read+0x2cc><== NOT EXECUTED
printf ("rtems-rfs: dir-read: "
ffc2437c: 80 9b 00 08 lwz r4,8(r27) <== NOT EXECUTED
ffc24380: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc24384: 80 e1 00 2c lwz r7,44(r1) <== NOT EXECUTED
ffc24388: 7e c5 b3 78 mr r5,r22 <== NOT EXECUTED
ffc2438c: 7e a6 ab 78 mr r6,r21 <== NOT EXECUTED
ffc24390: 38 63 d2 9c addi r3,r3,-11620 <== NOT EXECUTED
ffc24394: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc24398: 48 00 69 ad bl ffc2ad44 <printf> <== NOT EXECUTED
ffc2439c: 4b ff ff 70 b ffc2430c <rtems_rfs_dir_read+0x2cc> <== NOT EXECUTED
rtems_rfs_inode_ino (dir), elength, eino, map.bpos.boff);
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
ffc243a0: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc243a4: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc243a8: 38 a0 01 18 li r5,280 <== NOT EXECUTED
ffc243ac: 48 00 68 09 bl ffc2abb4 <memset> <== NOT EXECUTED
dirent->d_off = offset;
dirent->d_reclen = sizeof (struct dirent);
*length += elength;
ffc243b0: 80 17 00 00 lwz r0,0(r23) <== NOT EXECUTED
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
dirent->d_reclen = sizeof (struct dirent);
ffc243b4: 39 20 01 18 li r9,280 <== NOT EXECUTED
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
ffc243b8: 93 da 00 08 stw r30,8(r26) <== NOT EXECUTED
dirent->d_reclen = sizeof (struct dirent);
*length += elength;
ffc243bc: 7c 16 02 14 add r0,r22,r0 <== NOT EXECUTED
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
dirent->d_reclen = sizeof (struct dirent);
ffc243c0: b1 3a 00 10 sth r9,16(r26) <== NOT EXECUTED
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
ffc243c4: 93 fa 00 0c stw r31,12(r26) <== NOT EXECUTED
dirent->d_reclen = sizeof (struct dirent);
*length += elength;
ffc243c8: 90 17 00 00 stw r0,0(r23) <== NOT EXECUTED
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
ffc243cc: 81 3c 00 08 lwz r9,8(r28) <== NOT EXECUTED
ffc243d0: 7d 33 48 50 subf r9,r19,r9 <== NOT EXECUTED
ffc243d4: 7d 36 48 50 subf r9,r22,r9 <== NOT EXECUTED
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
ffc243d8: 2f 89 00 0a cmpwi cr7,r9,10 <== NOT EXECUTED
ffc243dc: 41 9d 00 0c bgt- cr7,ffc243e8 <rtems_rfs_dir_read+0x3a8><== NOT EXECUTED
*length += remaining;
ffc243e0: 7c 09 02 14 add r0,r9,r0 <== NOT EXECUTED
ffc243e4: 90 17 00 00 stw r0,0(r23) <== NOT EXECUTED
elength -= RTEMS_RFS_DIR_ENTRY_SIZE;
ffc243e8: 3a d6 ff f6 addi r22,r22,-10 <== NOT EXECUTED
ffc243ec: 2f 96 00 ff cmpwi cr7,r22,255 <== NOT EXECUTED
ffc243f0: 40 9d 00 08 ble- cr7,ffc243f8 <rtems_rfs_dir_read+0x3b8><== NOT EXECUTED
ffc243f4: 3a c0 00 ff li r22,255 <== NOT EXECUTED
if (elength > NAME_MAX)
elength = NAME_MAX;
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
ffc243f8: 3b da 00 14 addi r30,r26,20 <== NOT EXECUTED
ffc243fc: 38 94 00 0a addi r4,r20,10 <== NOT EXECUTED
ffc24400: 7e c5 b3 78 mr r5,r22 <== NOT EXECUTED
ffc24404: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc24408: 48 00 65 95 bl ffc2a99c <memcpy> <== NOT EXECUTED
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
ffc2440c: 89 54 00 00 lbz r10,0(r20) <== NOT EXECUTED
ffc24410: 89 74 00 01 lbz r11,1(r20) <== NOT EXECUTED
dirent->d_namlen = elength;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
ffc24414: 38 60 00 00 li r3,0 <== NOT EXECUTED
if (elength > NAME_MAX)
elength = NAME_MAX;
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
ffc24418: 89 34 00 03 lbz r9,3(r20) <== NOT EXECUTED
ffc2441c: 55 4a c0 0e rlwinm r10,r10,24,0,7 <== NOT EXECUTED
ffc24420: 88 14 00 02 lbz r0,2(r20) <== NOT EXECUTED
ffc24424: 55 6b 80 1e rlwinm r11,r11,16,0,15 <== NOT EXECUTED
ffc24428: 7d 4b 5b 78 or r11,r10,r11 <== NOT EXECUTED
dirent->d_namlen = elength;
ffc2442c: b2 da 00 12 sth r22,18(r26) <== NOT EXECUTED
if (elength > NAME_MAX)
elength = NAME_MAX;
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
ffc24430: 7d 69 4b 78 or r9,r11,r9 <== NOT EXECUTED
ffc24434: 54 00 40 2e rlwinm r0,r0,8,0,23 <== NOT EXECUTED
ffc24438: 7d 20 03 78 or r0,r9,r0 <== NOT EXECUTED
ffc2443c: 90 1a 00 00 stw r0,0(r26) <== NOT EXECUTED
dirent->d_namlen = elength;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
ffc24440: 3c 80 80 00 lis r4,-32768 <== NOT EXECUTED
ffc24444: 4b ff 35 25 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc24448: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc2444c: 41 9e fe c0 beq+ cr7,ffc2430c <rtems_rfs_dir_read+0x2cc><== NOT EXECUTED
printf ("rtems-rfs: dir-read: found off:%" PRIdoff_t " ino:%ld name=%s\n",
ffc24450: 80 ba 00 08 lwz r5,8(r26) <== NOT EXECUTED
ffc24454: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc24458: 80 da 00 0c lwz r6,12(r26) <== NOT EXECUTED
ffc2445c: 7f c8 f3 78 mr r8,r30 <== NOT EXECUTED
ffc24460: 80 fa 00 00 lwz r7,0(r26) <== NOT EXECUTED
ffc24464: 38 63 d2 e0 addi r3,r3,-11552 <== NOT EXECUTED
ffc24468: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc2446c: 48 00 68 d9 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc24470: 4b ff fe 9c b ffc2430c <rtems_rfs_dir_read+0x2cc> <== NOT EXECUTED
ffc24b18 <rtems_rfs_file_close>:
}
int
rtems_rfs_file_close (rtems_rfs_file_system* fs,
rtems_rfs_file_handle* handle)
{
ffc24b18: 94 21 ff e0 stwu r1,-32(r1)
ffc24b1c: 7d 80 00 26 mfcr r12
ffc24b20: 7c 08 02 a6 mflr r0
ffc24b24: 93 a1 00 14 stw r29,20(r1)
ffc24b28: 7c 7d 1b 78 mr r29,r3
int rrc;
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
ffc24b2c: 38 60 00 10 li r3,16
}
int
rtems_rfs_file_close (rtems_rfs_file_system* fs,
rtems_rfs_file_handle* handle)
{
ffc24b30: 93 e1 00 1c stw r31,28(r1)
ffc24b34: 7c 9f 23 78 mr r31,r4
int rrc;
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
ffc24b38: 38 80 00 00 li r4,0
}
int
rtems_rfs_file_close (rtems_rfs_file_system* fs,
rtems_rfs_file_handle* handle)
{
ffc24b3c: 90 01 00 24 stw r0,36(r1)
ffc24b40: 93 61 00 0c stw r27,12(r1)
ffc24b44: 93 81 00 10 stw r28,16(r1)
ffc24b48: 93 c1 00 18 stw r30,24(r1)
ffc24b4c: 91 81 00 08 stw r12,8(r1)
int rrc;
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
ffc24b50: 4b ff 2e 19 bl ffc17968 <rtems_rfs_trace>
ffc24b54: 2f 83 00 00 cmpwi cr7,r3,0
ffc24b58: 40 9e 02 5c bne- cr7,ffc24db4 <rtems_rfs_file_close+0x29c><== NEVER TAKEN
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
handle->shared->inode.ino);
if (handle->shared->references > 0)
ffc24b5c: 80 9f 00 1c lwz r4,28(r31)
ffc24b60: 81 24 00 08 lwz r9,8(r4)
ffc24b64: 2f 89 00 00 cmpwi cr7,r9,0
ffc24b68: 40 9d 00 10 ble- cr7,ffc24b78 <rtems_rfs_file_close+0x60><== NEVER TAKEN
handle->shared->references--;
ffc24b6c: 39 29 ff ff addi r9,r9,-1
ffc24b70: 2f 89 00 00 cmpwi cr7,r9,0
ffc24b74: 91 24 00 08 stw r9,8(r4)
if (handle->shared->references == 0)
ffc24b78: 40 9e 01 e0 bne- cr7,ffc24d58 <rtems_rfs_file_close+0x240><== NEVER TAKEN
{
if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))
ffc24b7c: 81 24 00 18 lwz r9,24(r4)
ffc24b80: 2f 89 00 00 cmpwi cr7,r9,0
ffc24b84: 41 9e 03 08 beq- cr7,ffc24e8c <rtems_rfs_file_close+0x374><== ALWAYS TAKEN
if (rrc == 0)
{
/*
* @todo This could be clever and only update if different.
*/
rtems_rfs_inode_set_atime (&handle->shared->inode,
ffc24b88: 80 04 00 8c lwz r0,140(r4)
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc24b8c: 39 40 00 01 li r10,1
*/
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
ffc24b90: 54 0b 46 3e rlwinm r11,r0,8,24,31
ffc24b94: 99 69 00 10 stb r11,16(r9)
ffc24b98: 54 08 84 3e rlwinm r8,r0,16,16,31
ffc24b9c: 54 0b c2 3e rlwinm r11,r0,24,8,31
ffc24ba0: 81 24 00 18 lwz r9,24(r4)
ffc24ba4: 99 09 00 11 stb r8,17(r9)
ffc24ba8: 81 24 00 18 lwz r9,24(r4)
ffc24bac: 99 69 00 12 stb r11,18(r9)
ffc24bb0: 81 24 00 18 lwz r9,24(r4)
ffc24bb4: 98 09 00 13 stb r0,19(r9)
handle->shared->atime);
rtems_rfs_inode_set_mtime (&handle->shared->inode,
ffc24bb8: 81 7f 00 1c lwz r11,28(r31)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc24bbc: 99 44 00 1c stb r10,28(r4)
ffc24bc0: 80 0b 00 90 lwz r0,144(r11)
*/
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
ffc24bc4: 81 2b 00 18 lwz r9,24(r11)
ffc24bc8: 54 08 46 3e rlwinm r8,r0,8,24,31
ffc24bcc: 99 09 00 14 stb r8,20(r9)
ffc24bd0: 54 07 84 3e rlwinm r7,r0,16,16,31
ffc24bd4: 54 08 c2 3e rlwinm r8,r0,24,8,31
ffc24bd8: 81 2b 00 18 lwz r9,24(r11)
ffc24bdc: 98 e9 00 15 stb r7,21(r9)
ffc24be0: 81 2b 00 18 lwz r9,24(r11)
ffc24be4: 99 09 00 16 stb r8,22(r9)
ffc24be8: 81 2b 00 18 lwz r9,24(r11)
ffc24bec: 98 09 00 17 stb r0,23(r9)
handle->shared->mtime);
rtems_rfs_inode_set_ctime (&handle->shared->inode,
ffc24bf0: 81 3f 00 1c lwz r9,28(r31)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc24bf4: 99 4b 00 1c stb r10,28(r11)
ffc24bf8: 80 09 00 94 lwz r0,148(r9)
*/
static inline void
rtems_rfs_inode_set_ctime (rtems_rfs_inode_handle* handle,
rtems_rfs_time ctime)
{
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
ffc24bfc: 81 69 00 18 lwz r11,24(r9)
ffc24c00: 54 08 46 3e rlwinm r8,r0,8,24,31
ffc24c04: 99 0b 00 18 stb r8,24(r11)
ffc24c08: 54 07 84 3e rlwinm r7,r0,16,16,31
ffc24c0c: 54 08 c2 3e rlwinm r8,r0,24,8,31
ffc24c10: 81 69 00 18 lwz r11,24(r9)
ffc24c14: 98 eb 00 19 stb r7,25(r11)
ffc24c18: 81 69 00 18 lwz r11,24(r9)
ffc24c1c: 99 0b 00 1a stb r8,26(r11)
ffc24c20: 81 69 00 18 lwz r11,24(r9)
ffc24c24: 98 0b 00 1b stb r0,27(r11)
handle->shared->ctime);
if (!rtems_rfs_block_size_equal (&handle->shared->size,
ffc24c28: 80 9f 00 1c lwz r4,28(r31)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc24c2c: 99 49 00 1c stb r10,28(r9)
ffc24c30: 80 04 00 84 lwz r0,132(r4)
ffc24c34: 81 24 00 3c lwz r9,60(r4)
ffc24c38: 7f 80 48 00 cmpw cr7,r0,r9
ffc24c3c: 81 24 00 88 lwz r9,136(r4)
ffc24c40: 41 9e 02 34 beq- cr7,ffc24e74 <rtems_rfs_file_close+0x35c><== ALWAYS TAKEN
static inline void
rtems_rfs_block_map_set_size (rtems_rfs_block_map* map,
rtems_rfs_block_size* size)
{
rtems_rfs_block_copy_size (&map->size, size);
map->dirty = true;
ffc24c44: 3b c0 00 00 li r30,0 <== NOT EXECUTED
*/
static inline void
rtems_rfs_block_map_set_size (rtems_rfs_block_map* map,
rtems_rfs_block_size* size)
{
rtems_rfs_block_copy_size (&map->size, size);
ffc24c48: 90 04 00 3c stw r0,60(r4) <== NOT EXECUTED
ffc24c4c: 2e 1e 00 00 cmpwi cr4,r30,0 <== NOT EXECUTED
map->dirty = true;
ffc24c50: 38 00 00 01 li r0,1 <== NOT EXECUTED
*/
static inline void
rtems_rfs_block_map_set_size (rtems_rfs_block_map* map,
rtems_rfs_block_size* size)
{
rtems_rfs_block_copy_size (&map->size, size);
ffc24c54: 91 24 00 40 stw r9,64(r4) <== NOT EXECUTED
map->dirty = true;
ffc24c58: 98 04 00 34 stb r0,52(r4) <== NOT EXECUTED
&handle->shared->map.size))
rtems_rfs_block_map_set_size (&handle->shared->map,
&handle->shared->size);
}
rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
ffc24c5c: 7f a3 eb 78 mr r3,r29
ffc24c60: 38 84 00 34 addi r4,r4,52
ffc24c64: 4b ff ca fd bl ffc21760 <rtems_rfs_block_map_close>
if (rc > 0)
ffc24c68: 7c 7c 1b 79 mr. r28,r3
ffc24c6c: 40 81 00 1c ble- ffc24c88 <rtems_rfs_file_close+0x170> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
ffc24c70: 38 60 00 10 li r3,16 <== NOT EXECUTED
ffc24c74: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc24c78: 4b ff 2c f1 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc24c7c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc24c80: 40 9e 01 c0 bne- cr7,ffc24e40 <rtems_rfs_file_close+0x328><== NOT EXECUTED
printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
ffc24c84: 41 92 01 7c beq- cr4,ffc24e00 <rtems_rfs_file_close+0x2e8><== NOT EXECUTED
rrc = rc;
}
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
ffc24c88: 80 9f 00 1c lwz r4,28(r31)
ffc24c8c: 7f a3 eb 78 mr r3,r29
ffc24c90: 38 84 00 0c addi r4,r4,12
ffc24c94: 4b fe f5 a5 bl ffc14238 <rtems_rfs_inode_close>
if (rc > 0)
ffc24c98: 7c 7c 1b 79 mr. r28,r3
ffc24c9c: 40 81 00 1c ble- ffc24cb8 <rtems_rfs_file_close+0x1a0> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
ffc24ca0: 38 60 00 10 li r3,16 <== NOT EXECUTED
ffc24ca4: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc24ca8: 4b ff 2c c1 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc24cac: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc24cb0: 40 9e 01 5c bne- cr7,ffc24e0c <rtems_rfs_file_close+0x2f4><== NOT EXECUTED
printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
ffc24cb4: 41 92 01 1c beq- cr4,ffc24dd0 <rtems_rfs_file_close+0x2b8><== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
ffc24cb8: 80 7f 00 1c lwz r3,28(r31)
ffc24cbc: 4b fe 9b 1d bl ffc0e7d8 <_Chain_Extract>
rrc = rc;
}
rtems_chain_extract (&handle->shared->link);
free (handle->shared);
ffc24cc0: 80 7f 00 1c lwz r3,28(r31)
ffc24cc4: 4b fe 38 1d bl ffc084e0 <free>
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc24cc8: 7f a3 eb 78 mr r3,r29
ffc24ccc: 38 9f 00 04 addi r4,r31,4
ffc24cd0: 4b ff d9 71 bl ffc22640 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
handle->bnum = 0;
ffc24cd4: 38 00 00 00 li r0,0
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc24cd8: 39 20 00 00 li r9,0
handle->bnum = 0;
ffc24cdc: 90 1f 00 08 stw r0,8(r31)
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc24ce0: 99 3f 00 04 stb r9,4(r31)
handle->bnum = 0;
handle->buffer = NULL;
ffc24ce4: 90 1f 00 0c stw r0,12(r31)
rc = rtems_rfs_buffer_handle_close (fs, &handle->buffer);
if ((rrc == 0) && (rc > 0))
rrc = rc;
if (rrc > 0)
ffc24ce8: 40 91 00 94 ble- cr4,ffc24d7c <rtems_rfs_file_close+0x264><== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
ffc24cec: 38 60 00 10 li r3,16 <== NOT EXECUTED
ffc24cf0: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc24cf4: 4b ff 2c 75 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc24cf8: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc24cfc: 41 be 00 80 beq+ cr7,ffc24d7c <rtems_rfs_file_close+0x264><== NOT EXECUTED
printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc));
ffc24d00: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc24d04: 48 00 6d ad bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc24d08: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc24d0c: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc24d10: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc24d14: 38 63 d5 38 addi r3,r3,-10952 <== NOT EXECUTED
ffc24d18: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc24d1c: 48 00 60 29 bl ffc2ad44 <printf> <== NOT EXECUTED
}
free (handle);
ffc24d20: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc24d24: 4b fe 37 bd bl ffc084e0 <free> <== NOT EXECUTED
return rrc;
}
ffc24d28: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
ffc24d2c: 81 81 00 08 lwz r12,8(r1) <== NOT EXECUTED
ffc24d30: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc24d34: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc24d38: 83 61 00 0c lwz r27,12(r1) <== NOT EXECUTED
ffc24d3c: 83 81 00 10 lwz r28,16(r1) <== NOT EXECUTED
ffc24d40: 7d 80 81 20 mtcrf 8,r12 <== NOT EXECUTED
ffc24d44: 83 a1 00 14 lwz r29,20(r1) <== NOT EXECUTED
ffc24d48: 83 c1 00 18 lwz r30,24(r1) <== NOT EXECUTED
ffc24d4c: 83 e1 00 1c lwz r31,28(r1) <== NOT EXECUTED
ffc24d50: 38 21 00 20 addi r1,r1,32 <== NOT EXECUTED
ffc24d54: 4e 80 00 20 blr <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc24d58: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc24d5c: 38 9f 00 04 addi r4,r31,4 <== NOT EXECUTED
ffc24d60: 4b ff d8 e1 bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
ffc24d64: 38 00 00 00 li r0,0 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc24d68: 39 20 00 00 li r9,0 <== NOT EXECUTED
handle->bnum = 0;
ffc24d6c: 90 1f 00 08 stw r0,8(r31) <== NOT EXECUTED
rtems_rfs_file_handle* handle)
{
int rrc;
int rc;
rrc = 0;
ffc24d70: 3b c0 00 00 li r30,0 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc24d74: 99 3f 00 04 stb r9,4(r31) <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
ffc24d78: 90 1f 00 0c stw r0,12(r31) <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc));
}
free (handle);
ffc24d7c: 7f e3 fb 78 mr r3,r31
ffc24d80: 4b fe 37 61 bl ffc084e0 <free>
return rrc;
}
ffc24d84: 80 01 00 24 lwz r0,36(r1)
ffc24d88: 81 81 00 08 lwz r12,8(r1)
ffc24d8c: 7f c3 f3 78 mr r3,r30
ffc24d90: 7c 08 03 a6 mtlr r0
ffc24d94: 83 61 00 0c lwz r27,12(r1)
ffc24d98: 83 81 00 10 lwz r28,16(r1)
ffc24d9c: 7d 80 81 20 mtcrf 8,r12
ffc24da0: 83 a1 00 14 lwz r29,20(r1)
ffc24da4: 83 c1 00 18 lwz r30,24(r1)
ffc24da8: 83 e1 00 1c lwz r31,28(r1)
ffc24dac: 38 21 00 20 addi r1,r1,32
ffc24db0: 4e 80 00 20 blr
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
handle->shared->inode.ino);
ffc24db4: 81 3f 00 1c lwz r9,28(r31) <== NOT EXECUTED
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
ffc24db8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc24dbc: 38 63 d4 98 addi r3,r3,-11112 <== NOT EXECUTED
ffc24dc0: 80 89 00 14 lwz r4,20(r9) <== NOT EXECUTED
ffc24dc4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc24dc8: 48 00 5f 7d bl ffc2ad44 <printf> <== NOT EXECUTED
ffc24dcc: 4b ff fd 90 b ffc24b5c <rtems_rfs_file_close+0x44> <== NOT EXECUTED
ffc24dd0: 80 7f 00 1c lwz r3,28(r31) <== NOT EXECUTED
ffc24dd4: 4b fe 9a 05 bl ffc0e7d8 <_Chain_Extract> <== NOT EXECUTED
if (rrc == 0)
rrc = rc;
}
rtems_chain_extract (&handle->shared->link);
free (handle->shared);
ffc24dd8: 80 7f 00 1c lwz r3,28(r31) <== NOT EXECUTED
ffc24ddc: 4b fe 37 05 bl ffc084e0 <free> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc24de0: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc24de4: 38 9f 00 04 addi r4,r31,4 <== NOT EXECUTED
ffc24de8: 4b ff d8 59 bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
ffc24dec: 9b df 00 04 stb r30,4(r31) <== NOT EXECUTED
handle->bnum = 0;
ffc24df0: 93 df 00 08 stw r30,8(r31) <== NOT EXECUTED
handle->buffer = NULL;
ffc24df4: 93 df 00 0c stw r30,12(r31) <== NOT EXECUTED
ffc24df8: 7f 9e e3 78 mr r30,r28 <== NOT EXECUTED
ffc24dfc: 4b ff fe f0 b ffc24cec <rtems_rfs_file_close+0x1d4> <== NOT EXECUTED
ffc24e00: 7f 9e e3 78 mr r30,r28 <== NOT EXECUTED
ffc24e04: 2e 1c 00 00 cmpwi cr4,r28,0 <== NOT EXECUTED
ffc24e08: 4b ff fe 80 b ffc24c88 <rtems_rfs_file_close+0x170> <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
handle->shared->inode.ino, rc, strerror (rc));
ffc24e0c: 81 3f 00 1c lwz r9,28(r31) <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
ffc24e10: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc24e14: 83 69 00 14 lwz r27,20(r9) <== NOT EXECUTED
ffc24e18: 48 00 6c 99 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc24e1c: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc24e20: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc24e24: 38 63 d4 fc addi r3,r3,-11012 <== NOT EXECUTED
ffc24e28: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc24e2c: 7f 85 e3 78 mr r5,r28 <== NOT EXECUTED
ffc24e30: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc24e34: 48 00 5f 11 bl ffc2ad44 <printf> <== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
ffc24e38: 41 b2 ff 98 beq- cr4,ffc24dd0 <rtems_rfs_file_close+0x2b8><== NOT EXECUTED
ffc24e3c: 4b ff fe 7c b ffc24cb8 <rtems_rfs_file_close+0x1a0> <== NOT EXECUTED
rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
handle->shared->inode.ino, rc, strerror (rc));
ffc24e40: 81 3f 00 1c lwz r9,28(r31) <== NOT EXECUTED
rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
ffc24e44: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc24e48: 83 69 00 14 lwz r27,20(r9) <== NOT EXECUTED
ffc24e4c: 48 00 6c 65 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc24e50: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc24e54: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc24e58: 38 63 d4 c0 addi r3,r3,-11072 <== NOT EXECUTED
ffc24e5c: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc24e60: 7f 85 e3 78 mr r5,r28 <== NOT EXECUTED
ffc24e64: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc24e68: 48 00 5e dd bl ffc2ad44 <printf> <== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
ffc24e6c: 40 b2 fe 1c bne- cr4,ffc24c88 <rtems_rfs_file_close+0x170><== NOT EXECUTED
ffc24e70: 4b ff ff 90 b ffc24e00 <rtems_rfs_file_close+0x2e8> <== NOT EXECUTED
handle->shared->atime);
rtems_rfs_inode_set_mtime (&handle->shared->inode,
handle->shared->mtime);
rtems_rfs_inode_set_ctime (&handle->shared->inode,
handle->shared->ctime);
if (!rtems_rfs_block_size_equal (&handle->shared->size,
ffc24e74: 81 64 00 40 lwz r11,64(r4)
ffc24e78: 3b c0 00 00 li r30,0
ffc24e7c: 2e 1e 00 00 cmpwi cr4,r30,0
ffc24e80: 7f 89 58 00 cmpw cr7,r9,r11
ffc24e84: 40 9e fd c0 bne+ cr7,ffc24c44 <rtems_rfs_file_close+0x12c><== NEVER TAKEN
ffc24e88: 4b ff fd d4 b ffc24c5c <rtems_rfs_file_close+0x144>
handle->shared->references--;
if (handle->shared->references == 0)
{
if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))
rrc = rtems_rfs_inode_load (fs, &handle->shared->inode);
ffc24e8c: 38 84 00 0c addi r4,r4,12
ffc24e90: 7f a3 eb 78 mr r3,r29
ffc24e94: 4b fe f0 71 bl ffc13f04 <rtems_rfs_inode_load>
if (rrc == 0)
ffc24e98: 80 9f 00 1c lwz r4,28(r31)
ffc24e9c: 2e 03 00 00 cmpwi cr4,r3,0
ffc24ea0: 7c 7e 1b 78 mr r30,r3
ffc24ea4: 40 92 fd b8 bne+ cr4,ffc24c5c <rtems_rfs_file_close+0x144><== NEVER TAKEN
ffc24ea8: 81 24 00 18 lwz r9,24(r4)
ffc24eac: 4b ff fc dc b ffc24b88 <rtems_rfs_file_close+0x70>
ffc258c8 <rtems_rfs_file_get_shared>:
ffc258c8: 81 23 00 70 lwz r9,112(r3)
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
ffc258cc: 38 03 00 74 addi r0,r3,116
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
return shared;
node = rtems_chain_next (node);
}
return NULL;
ffc258d0: 38 60 00 00 li r3,0
rtems_rfs_file_get_shared (rtems_rfs_file_system* fs,
rtems_rfs_ino ino)
{
rtems_chain_node* node;
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
ffc258d4: 7f 89 00 00 cmpw cr7,r9,r0
ffc258d8: 4d 9e 00 20 beqlr cr7
{
rtems_rfs_file_shared* shared;
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
ffc258dc: 81 69 00 14 lwz r11,20(r9) <== NOT EXECUTED
ffc258e0: 7d 23 4b 78 mr r3,r9 <== NOT EXECUTED
ffc258e4: 7f 8b 20 00 cmpw cr7,r11,r4 <== NOT EXECUTED
ffc258e8: 40 be 00 14 bne+ cr7,ffc258fc <rtems_rfs_file_get_shared+0x34><== NOT EXECUTED
ffc258ec: 4e 80 00 20 blr <== NOT EXECUTED
ffc258f0: 81 69 00 14 lwz r11,20(r9) <== NOT EXECUTED
ffc258f4: 7f 8b 20 00 cmpw cr7,r11,r4 <== NOT EXECUTED
ffc258f8: 41 9e 00 18 beq- cr7,ffc25910 <rtems_rfs_file_get_shared+0x48><== NOT EXECUTED
return shared;
node = rtems_chain_next (node);
}
return NULL;
}
ffc258fc: 81 29 00 00 lwz r9,0(r9) <== NOT EXECUTED
rtems_rfs_file_get_shared (rtems_rfs_file_system* fs,
rtems_rfs_ino ino)
{
rtems_chain_node* node;
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
ffc25900: 7f 89 00 00 cmpw cr7,r9,r0 <== NOT EXECUTED
ffc25904: 40 9e ff ec bne+ cr7,ffc258f0 <rtems_rfs_file_get_shared+0x28><== NOT EXECUTED
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
return shared;
node = rtems_chain_next (node);
}
return NULL;
ffc25908: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc2590c: 4e 80 00 20 blr <== NOT EXECUTED
}
ffc25910: 7d 23 4b 78 mr r3,r9 <== NOT EXECUTED
ffc25914: 4e 80 00 20 blr <== NOT EXECUTED
ffc2510c <rtems_rfs_file_io_end>:
int
rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
size_t size,
bool read)
{
ffc2510c: 94 21 ff e0 stwu r1,-32(r1)
ffc25110: 7d 80 00 26 mfcr r12
ffc25114: 7c 08 02 a6 mflr r0
ffc25118: 93 a1 00 14 stw r29,20(r1)
ffc2511c: 7c 9d 23 78 mr r29,r4
bool atime;
bool mtime;
bool length;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc25120: 38 80 00 00 li r4,0
int
rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
size_t size,
bool read)
{
ffc25124: 93 e1 00 1c stw r31,28(r1)
ffc25128: 7c 7f 1b 78 mr r31,r3
bool atime;
bool mtime;
bool length;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc2512c: 38 60 00 20 li r3,32
int
rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
size_t size,
bool read)
{
ffc25130: 93 c1 00 18 stw r30,24(r1)
ffc25134: 7c be 2b 78 mr r30,r5
ffc25138: 2e 1e 00 00 cmpwi cr4,r30,0
ffc2513c: 90 01 00 24 stw r0,36(r1)
ffc25140: 93 61 00 0c stw r27,12(r1)
ffc25144: 93 81 00 10 stw r28,16(r1)
ffc25148: 91 81 00 08 stw r12,8(r1)
bool atime;
bool mtime;
bool length;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc2514c: 4b ff 28 1d bl ffc17968 <rtems_rfs_trace>
ffc25150: 2f 83 00 00 cmpwi cr7,r3,0
ffc25154: 41 9e 00 24 beq- cr7,ffc25178 <rtems_rfs_file_io_end+0x6c><== ALWAYS TAKEN
printf ("rtems-rfs: file-io: end: %s size=%zu\n",
ffc25158: 41 92 02 18 beq- cr4,ffc25370 <rtems_rfs_file_io_end+0x264><== NOT EXECUTED
ffc2515c: 3c 80 ff c4 lis r4,-60 <== NOT EXECUTED
ffc25160: 38 84 be 90 addi r4,r4,-16752 <== NOT EXECUTED
ffc25164: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc25168: 38 63 d6 14 addi r3,r3,-10732 <== NOT EXECUTED
ffc2516c: 7f a5 eb 78 mr r5,r29 <== NOT EXECUTED
ffc25170: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc25174: 48 00 5b d1 bl ffc2ad44 <printf> <== NOT EXECUTED
read ? "read" : "write", size);
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
ffc25178: 80 1f 00 0c lwz r0,12(r31)
ffc2517c: 2f 80 00 00 cmpwi cr7,r0,0
ffc25180: 41 9e 02 64 beq- cr7,ffc253e4 <rtems_rfs_file_io_end+0x2d8><== NEVER TAKEN
{
if (!read)
ffc25184: 41 92 00 80 beq- cr4,ffc25204 <rtems_rfs_file_io_end+0xf8>
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
ffc25188: 81 3f 00 1c lwz r9,28(r31)
ffc2518c: 38 9f 00 04 addi r4,r31,4
ffc25190: 80 69 00 98 lwz r3,152(r9)
ffc25194: 4b ff d4 ad bl ffc22640 <rtems_rfs_buffer_handle_release>
rtems_rfs_file_buffer (handle));
if (rc > 0)
ffc25198: 7c 7e 1b 79 mr. r30,r3
ffc2519c: 40 81 00 88 ble- ffc25224 <rtems_rfs_file_io_end+0x118> <== ALWAYS TAKEN
{
printf (
ffc251a0: 40 92 01 dc bne- cr4,ffc2537c <rtems_rfs_file_io_end+0x270><== NOT EXECUTED
ffc251a4: 3f e0 ff c4 lis r31,-60 <== NOT EXECUTED
ffc251a8: 3b ff 9e 8c addi r31,r31,-24948 <== NOT EXECUTED
ffc251ac: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc251b0: 48 00 69 01 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc251b4: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc251b8: 7c 67 1b 78 mr r7,r3 <== NOT EXECUTED
ffc251bc: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc251c0: 38 63 d6 3c addi r3,r3,-10692 <== NOT EXECUTED
ffc251c4: 7f a5 eb 78 mr r5,r29 <== NOT EXECUTED
ffc251c8: 7f c6 f3 78 mr r6,r30 <== NOT EXECUTED
ffc251cc: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc251d0: 48 00 5b 75 bl ffc2ad44 <printf> <== NOT EXECUTED
handle->shared->size.offset =
rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
}
return rc;
}
ffc251d4: 80 01 00 24 lwz r0,36(r1)
ffc251d8: 7f c3 f3 78 mr r3,r30
ffc251dc: 81 81 00 08 lwz r12,8(r1)
ffc251e0: 7c 08 03 a6 mtlr r0
ffc251e4: 83 61 00 0c lwz r27,12(r1)
ffc251e8: 83 81 00 10 lwz r28,16(r1)
ffc251ec: 7d 83 81 20 mtcrf 56,r12
ffc251f0: 83 a1 00 14 lwz r29,20(r1)
ffc251f4: 83 c1 00 18 lwz r30,24(r1)
ffc251f8: 83 e1 00 1c lwz r31,28(r1)
ffc251fc: 38 21 00 20 addi r1,r1,32
ffc25200: 4e 80 00 20 blr
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
{
if (!read)
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
ffc25204: 81 3f 00 1c lwz r9,28(r31)
read ? "read" : "write", size);
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
{
if (!read)
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
ffc25208: 38 00 00 01 li r0,1
ffc2520c: 98 1f 00 04 stb r0,4(r31)
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
ffc25210: 38 9f 00 04 addi r4,r31,4
ffc25214: 80 69 00 98 lwz r3,152(r9)
ffc25218: 4b ff d4 29 bl ffc22640 <rtems_rfs_buffer_handle_release>
rtems_rfs_file_buffer (handle));
if (rc > 0)
ffc2521c: 7c 7e 1b 79 mr. r30,r3
ffc25220: 41 81 ff 80 bgt+ ffc251a0 <rtems_rfs_file_io_end+0x94> <== NEVER TAKEN
* the size with the new length. The map holds the block count.
*/
handle->bpos.boff += size;
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
ffc25224: 81 3f 00 1c lwz r9,28(r31)
* increase the block number and adjust the offset.
*
* If we are the last block and the position is past the current size update
* the size with the new length. The map holds the block count.
*/
handle->bpos.boff += size;
ffc25228: 80 1f 00 14 lwz r0,20(r31)
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
ffc2522c: 81 69 00 98 lwz r11,152(r9)
* increase the block number and adjust the offset.
*
* If we are the last block and the position is past the current size update
* the size with the new length. The map holds the block count.
*/
handle->bpos.boff += size;
ffc25230: 7f bd 02 14 add r29,r29,r0
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
ffc25234: 80 0b 00 08 lwz r0,8(r11)
* increase the block number and adjust the offset.
*
* If we are the last block and the position is past the current size update
* the size with the new length. The map holds the block count.
*/
handle->bpos.boff += size;
ffc25238: 93 bf 00 14 stw r29,20(r31)
if (handle->bpos.boff >=
ffc2523c: 7f 9d 00 40 cmplw cr7,r29,r0
ffc25240: 41 9c 00 18 blt- cr7,ffc25258 <rtems_rfs_file_io_end+0x14c><== ALWAYS TAKEN
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
{
handle->bpos.bno++;
ffc25244: 81 7f 00 10 lwz r11,16(r31) <== NOT EXECUTED
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
ffc25248: 7f a0 e8 50 subf r29,r0,r29 <== NOT EXECUTED
ffc2524c: 93 bf 00 14 stw r29,20(r31) <== NOT EXECUTED
handle->bpos.boff += size;
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
{
handle->bpos.bno++;
ffc25250: 38 0b 00 01 addi r0,r11,1 <== NOT EXECUTED
ffc25254: 90 1f 00 10 stw r0,16(r31) <== NOT EXECUTED
}
length = false;
mtime = false;
if (!read &&
ffc25258: 41 92 01 30 beq- cr4,ffc25388 <rtems_rfs_file_io_end+0x27c>
handle->bpos.bno++;
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
}
length = false;
mtime = false;
ffc2525c: 3b 80 00 00 li r28,0
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
ffc25260: 80 1f 00 00 lwz r0,0(r31)
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
ffc25264: 3b a0 00 00 li r29,0
ffc25268: 70 09 00 02 andi. r9,r0,2
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
ffc2526c: 54 09 07 fe clrlwi r9,r0,31
ffc25270: 2f 89 00 00 cmpwi cr7,r9,0
ffc25274: 7f 60 00 26 mfcr r27
ffc25278: 57 7b ff fe rlwinm r27,r27,31,31,31
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
ffc2527c: 40 82 00 08 bne- ffc25284 <rtems_rfs_file_io_end+0x178> <== NEVER TAKEN
ffc25280: 57 9d 06 3e clrlwi r29,r28,24
length = rtems_rfs_file_update_length (handle) && length;
ffc25284: 54 00 f7 fe rlwinm r0,r0,30,31,31
ffc25288: 30 00 ff ff addic r0,r0,-1
ffc2528c: 7c 00 01 10 subfe r0,r0,r0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc25290: 38 60 00 20 li r3,32
ffc25294: 38 80 00 00 li r4,0
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
length = rtems_rfs_file_update_length (handle) && length;
ffc25298: 7f 9c 00 38 and r28,r28,r0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc2529c: 4b ff 26 cd bl ffc17968 <rtems_rfs_trace>
ffc252a0: 2f 83 00 00 cmpwi cr7,r3,0
ffc252a4: 2d 9b 00 00 cmpwi cr3,r27,0
ffc252a8: 2d 1c 00 00 cmpwi cr2,r28,0
ffc252ac: 41 9e 00 58 beq- cr7,ffc25304 <rtems_rfs_file_io_end+0x1f8><== ALWAYS TAKEN
printf ("rtems-rfs: file-io: end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n",
ffc252b0: 7c c0 00 26 mfcr r6 <== NOT EXECUTED
ffc252b4: 54 c6 7f fe rlwinm r6,r6,15,31,31 <== NOT EXECUTED
ffc252b8: 30 fd ff ff addic r7,r29,-1 <== NOT EXECUTED
ffc252bc: 7c e7 39 10 subfe r7,r7,r7 <== NOT EXECUTED
ffc252c0: 7d 00 00 26 mfcr r8 <== NOT EXECUTED
ffc252c4: 55 08 5f fe rlwinm r8,r8,11,31,31 <== NOT EXECUTED
ffc252c8: 80 9f 00 10 lwz r4,16(r31) <== NOT EXECUTED
ffc252cc: 7c c6 00 d0 neg r6,r6 <== NOT EXECUTED
ffc252d0: 80 bf 00 14 lwz r5,20(r31) <== NOT EXECUTED
ffc252d4: 7d 08 00 d0 neg r8,r8 <== NOT EXECUTED
ffc252d8: 38 00 ff ec li r0,-20 <== NOT EXECUTED
ffc252dc: 7c c6 00 38 and r6,r6,r0 <== NOT EXECUTED
ffc252e0: 54 e7 00 34 rlwinm r7,r7,0,0,26 <== NOT EXECUTED
ffc252e4: 55 08 07 f4 rlwinm r8,r8,0,31,26 <== NOT EXECUTED
ffc252e8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc252ec: 38 63 d6 80 addi r3,r3,-10624 <== NOT EXECUTED
ffc252f0: 38 c6 00 41 addi r6,r6,65 <== NOT EXECUTED
ffc252f4: 38 e7 00 4d addi r7,r7,77 <== NOT EXECUTED
ffc252f8: 39 08 00 4c addi r8,r8,76 <== NOT EXECUTED
ffc252fc: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc25300: 48 00 5a 45 bl ffc2ad44 <printf> <== NOT EXECUTED
handle->bpos.bno, handle->bpos.boff,
atime ? 'A' : '-', mtime ? 'M' : '-', length ? 'L' : '-');
if (atime || mtime)
ffc25304: 40 8e 00 0c bne- cr3,ffc25310 <rtems_rfs_file_io_end+0x204><== ALWAYS TAKEN
ffc25308: 2f 9d 00 00 cmpwi cr7,r29,0 <== NOT EXECUTED
ffc2530c: 41 9e 00 1c beq- cr7,ffc25328 <rtems_rfs_file_io_end+0x21c><== NOT EXECUTED
{
time_t now = time (NULL);
ffc25310: 38 60 00 00 li r3,0
ffc25314: 48 00 92 b1 bl ffc2e5c4 <time>
if (read && atime)
ffc25318: 41 92 00 f4 beq- cr4,ffc2540c <rtems_rfs_file_io_end+0x300>
ffc2531c: 41 8e 00 0c beq- cr3,ffc25328 <rtems_rfs_file_io_end+0x21c><== NEVER TAKEN
handle->shared->atime = now;
ffc25320: 81 3f 00 1c lwz r9,28(r31)
ffc25324: 90 69 00 8c stw r3,140(r9)
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
ffc25328: 41 aa fe ac beq- cr2,ffc251d4 <rtems_rfs_file_io_end+0xc8>
{
handle->shared->size.count =
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
ffc2532c: 81 3f 00 1c lwz r9,28(r31)
handle->shared->size.offset =
rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
}
return rc;
}
ffc25330: 7f c3 f3 78 mr r3,r30
ffc25334: 81 81 00 08 lwz r12,8(r1)
}
if (length)
{
handle->shared->size.count =
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
handle->shared->size.offset =
ffc25338: 80 09 00 40 lwz r0,64(r9)
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
{
handle->shared->size.count =
ffc2533c: 81 69 00 3c lwz r11,60(r9)
handle->shared->size.offset =
rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
}
return rc;
}
ffc25340: 7d 83 81 20 mtcrf 56,r12
}
if (length)
{
handle->shared->size.count =
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
handle->shared->size.offset =
ffc25344: 90 09 00 88 stw r0,136(r9)
rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
}
return rc;
}
ffc25348: 80 01 00 24 lwz r0,36(r1)
ffc2534c: 83 61 00 0c lwz r27,12(r1)
ffc25350: 7c 08 03 a6 mtlr r0
ffc25354: 83 81 00 10 lwz r28,16(r1)
ffc25358: 83 a1 00 14 lwz r29,20(r1)
ffc2535c: 83 c1 00 18 lwz r30,24(r1)
ffc25360: 83 e1 00 1c lwz r31,28(r1)
ffc25364: 38 21 00 20 addi r1,r1,32
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
{
handle->shared->size.count =
ffc25368: 91 69 00 84 stw r11,132(r9)
handle->shared->size.offset =
rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
}
return rc;
}
ffc2536c: 4e 80 00 20 blr
bool mtime;
bool length;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: end: %s size=%zu\n",
ffc25370: 3c 80 ff c4 lis r4,-60 <== NOT EXECUTED
ffc25374: 38 84 9e 8c addi r4,r4,-24948 <== NOT EXECUTED
ffc25378: 4b ff fd ec b ffc25164 <rtems_rfs_file_io_end+0x58> <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
rtems_rfs_file_buffer (handle));
if (rc > 0)
{
printf (
ffc2537c: 3f e0 ff c4 lis r31,-60 <== NOT EXECUTED
ffc25380: 3b ff be 90 addi r31,r31,-16752 <== NOT EXECUTED
ffc25384: 4b ff fe 28 b ffc251ac <rtems_rfs_file_io_end+0xa0> <== NOT EXECUTED
length = false;
mtime = false;
if (!read &&
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
ffc25388: 80 1f 00 10 lwz r0,16(r31)
ffc2538c: 81 69 00 3c lwz r11,60(r9)
}
length = false;
mtime = false;
if (!read &&
ffc25390: 2f 80 00 00 cmpwi cr7,r0,0
ffc25394: 41 9e 00 24 beq- cr7,ffc253b8 <rtems_rfs_file_io_end+0x2ac><== ALWAYS TAKEN
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
ffc25398: 2f 8b 00 00 cmpwi cr7,r11,0 <== NOT EXECUTED
ffc2539c: 40 9e 00 1c bne- cr7,ffc253b8 <rtems_rfs_file_io_end+0x2ac><== NOT EXECUTED
ffc253a0: 80 1f 00 14 lwz r0,20(r31) <== NOT EXECUTED
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
ffc253a4: 90 09 00 40 stw r0,64(r9)
map->dirty = true;
ffc253a8: 38 00 00 01 li r0,1
rtems_rfs_file_bpos (handle)))
{
rtems_rfs_block_map_set_size_offset (rtems_rfs_file_map (handle),
handle->bpos.boff);
length = true;
mtime = true;
ffc253ac: 3b 80 00 01 li r28,1
ffc253b0: 98 09 00 34 stb r0,52(r9)
ffc253b4: 4b ff fe ac b ffc25260 <rtems_rfs_file_io_end+0x154>
length = false;
mtime = false;
if (!read &&
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
ffc253b8: 7f 80 58 40 cmplw cr7,r0,r11
ffc253bc: 40 bc ff e4 bge- cr7,ffc253a0 <rtems_rfs_file_io_end+0x294><== NEVER TAKEN
ffc253c0: 39 6b ff ff addi r11,r11,-1
ffc253c4: 7f 80 58 00 cmpw cr7,r0,r11
handle->bpos.bno++;
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
}
length = false;
mtime = false;
ffc253c8: 3b 80 00 00 li r28,0
if (!read &&
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
ffc253cc: 40 9e fe 94 bne+ cr7,ffc25260 <rtems_rfs_file_io_end+0x154><== NEVER TAKEN
ffc253d0: 80 1f 00 14 lwz r0,20(r31)
ffc253d4: 81 69 00 40 lwz r11,64(r9)
ffc253d8: 7f 80 58 40 cmplw cr7,r0,r11
ffc253dc: 40 bd fe 84 ble- cr7,ffc25260 <rtems_rfs_file_io_end+0x154>
ffc253e0: 4b ff ff c4 b ffc253a4 <rtems_rfs_file_io_end+0x298>
* the size with the new length. The map holds the block count.
*/
handle->bpos.boff += size;
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
ffc253e4: 81 3f 00 1c lwz r9,28(r31) <== NOT EXECUTED
bool read)
{
bool atime;
bool mtime;
bool length;
int rc = 0;
ffc253e8: 3b c0 00 00 li r30,0 <== NOT EXECUTED
* increase the block number and adjust the offset.
*
* If we are the last block and the position is past the current size update
* the size with the new length. The map holds the block count.
*/
handle->bpos.boff += size;
ffc253ec: 80 1f 00 14 lwz r0,20(r31) <== NOT EXECUTED
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
ffc253f0: 81 69 00 98 lwz r11,152(r9) <== NOT EXECUTED
* increase the block number and adjust the offset.
*
* If we are the last block and the position is past the current size update
* the size with the new length. The map holds the block count.
*/
handle->bpos.boff += size;
ffc253f4: 7f bd 02 14 add r29,r29,r0 <== NOT EXECUTED
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
ffc253f8: 80 0b 00 08 lwz r0,8(r11) <== NOT EXECUTED
* increase the block number and adjust the offset.
*
* If we are the last block and the position is past the current size update
* the size with the new length. The map holds the block count.
*/
handle->bpos.boff += size;
ffc253fc: 93 bf 00 14 stw r29,20(r31) <== NOT EXECUTED
if (handle->bpos.boff >=
ffc25400: 7f 9d 00 40 cmplw cr7,r29,r0 <== NOT EXECUTED
ffc25404: 41 bc fe 54 blt- cr7,ffc25258 <rtems_rfs_file_io_end+0x14c><== NOT EXECUTED
ffc25408: 4b ff fe 3c b ffc25244 <rtems_rfs_file_io_end+0x138> <== NOT EXECUTED
if (atime || mtime)
{
time_t now = time (NULL);
if (read && atime)
handle->shared->atime = now;
if (!read && mtime)
ffc2540c: 2f 9d 00 00 cmpwi cr7,r29,0
ffc25410: 41 be ff 18 beq- cr7,ffc25328 <rtems_rfs_file_io_end+0x21c>
handle->shared->mtime = now;
ffc25414: 81 3f 00 1c lwz r9,28(r31)
ffc25418: 90 69 00 90 stw r3,144(r9)
ffc2541c: 4b ff ff 0c b ffc25328 <rtems_rfs_file_io_end+0x21c>
ffc25420 <rtems_rfs_file_io_release>:
return rc;
}
int
rtems_rfs_file_io_release (rtems_rfs_file_handle* handle)
{
ffc25420: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc25424: 94 21 ff f8 stwu r1,-8(r1) <== NOT EXECUTED
ffc25428: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc2542c: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
ffc25430: 80 03 00 0c lwz r0,12(r3) <== NOT EXECUTED
}
int
rtems_rfs_file_io_release (rtems_rfs_file_handle* handle)
{
int rc = 0;
ffc25434: 38 60 00 00 li r3,0 <== NOT EXECUTED
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
ffc25438: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc2543c: 41 9e 00 14 beq- cr7,ffc25450 <rtems_rfs_file_io_release+0x30><== NOT EXECUTED
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
ffc25440: 81 24 00 1c lwz r9,28(r4) <== NOT EXECUTED
ffc25444: 38 84 00 04 addi r4,r4,4 <== NOT EXECUTED
ffc25448: 80 69 00 98 lwz r3,152(r9) <== NOT EXECUTED
ffc2544c: 4b ff d1 f5 bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
rtems_rfs_file_buffer (handle));
return rc;
}
ffc25450: 80 01 00 0c lwz r0,12(r1) <== NOT EXECUTED
ffc25454: 38 21 00 08 addi r1,r1,8 <== NOT EXECUTED
ffc25458: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc2545c: 4e 80 00 20 blr <== NOT EXECUTED
ffc24eb0 <rtems_rfs_file_io_start>:
int
rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
size_t* available,
bool read)
{
ffc24eb0: 94 21 ff d0 stwu r1,-48(r1)
ffc24eb4: 7d 80 00 26 mfcr r12
ffc24eb8: 7c 08 02 a6 mflr r0
ffc24ebc: 93 c1 00 28 stw r30,40(r1)
ffc24ec0: 7c 9e 23 78 mr r30,r4
size_t size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc24ec4: 38 80 00 00 li r4,0
int
rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
size_t* available,
bool read)
{
ffc24ec8: 93 e1 00 2c stw r31,44(r1)
ffc24ecc: 7c 7f 1b 78 mr r31,r3
size_t size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc24ed0: 38 60 00 20 li r3,32
int
rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
size_t* available,
bool read)
{
ffc24ed4: 93 a1 00 24 stw r29,36(r1)
ffc24ed8: 7c bd 2b 78 mr r29,r5
ffc24edc: 2e 1d 00 00 cmpwi cr4,r29,0
ffc24ee0: 90 01 00 34 stw r0,52(r1)
ffc24ee4: 93 61 00 1c stw r27,28(r1)
ffc24ee8: 93 81 00 20 stw r28,32(r1)
ffc24eec: 91 81 00 18 stw r12,24(r1)
size_t size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc24ef0: 4b ff 2a 79 bl ffc17968 <rtems_rfs_trace>
ffc24ef4: 2f 83 00 00 cmpwi cr7,r3,0
ffc24ef8: 41 9e 00 28 beq- cr7,ffc24f20 <rtems_rfs_file_io_start+0x70><== ALWAYS TAKEN
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
ffc24efc: 40 92 00 d4 bne- cr4,ffc24fd0 <rtems_rfs_file_io_start+0x120><== NOT EXECUTED
ffc24f00: 3c 80 ff c4 lis r4,-60 <== NOT EXECUTED
ffc24f04: 38 84 9e 8c addi r4,r4,-24948 <== NOT EXECUTED
ffc24f08: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc24f0c: 80 bf 00 10 lwz r5,16(r31) <== NOT EXECUTED
ffc24f10: 80 df 00 14 lwz r6,20(r31) <== NOT EXECUTED
ffc24f14: 38 63 d5 60 addi r3,r3,-10912 <== NOT EXECUTED
ffc24f18: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc24f1c: 48 00 5e 29 bl ffc2ad44 <printf> <== NOT EXECUTED
read ? "read" : "write", handle->bpos.bno, handle->bpos.boff);
if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))
ffc24f20: 83 9f 00 0c lwz r28,12(r31)
ffc24f24: 2f 9c 00 00 cmpwi cr7,r28,0
ffc24f28: 41 9e 00 c4 beq- cr7,ffc24fec <rtems_rfs_file_io_start+0x13c><== ALWAYS TAKEN
if (rc > 0)
return rc;
}
if (read
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
ffc24f2c: 81 3f 00 1c lwz r9,28(r31)
block, request_read);
if (rc > 0)
return rc;
}
if (read
ffc24f30: 40 92 00 78 bne- cr4,ffc24fa8 <rtems_rfs_file_io_start+0xf8>
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
size = rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
else
size = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
ffc24f34: 81 29 00 98 lwz r9,152(r9)
ffc24f38: 83 a9 00 08 lwz r29,8(r9)
*available = size - rtems_rfs_file_block_offset (handle);
ffc24f3c: 80 1f 00 14 lwz r0,20(r31)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc24f40: 38 60 00 20 li r3,32
ffc24f44: 38 80 00 00 li r4,0
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
size = rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
else
size = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
*available = size - rtems_rfs_file_block_offset (handle);
ffc24f48: 7c 00 e8 50 subf r0,r0,r29
ffc24f4c: 90 1e 00 00 stw r0,0(r30)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
*available, size);
return 0;
ffc24f50: 3b 60 00 00 li r27,0
else
size = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
*available = size - rtems_rfs_file_block_offset (handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc24f54: 4b ff 2a 15 bl ffc17968 <rtems_rfs_trace>
ffc24f58: 2f 83 00 00 cmpwi cr7,r3,0
ffc24f5c: 41 be 00 1c beq+ cr7,ffc24f78 <rtems_rfs_file_io_start+0xc8><== ALWAYS TAKEN
printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
ffc24f60: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc24f64: 80 9e 00 00 lwz r4,0(r30) <== NOT EXECUTED
ffc24f68: 38 63 d5 e4 addi r3,r3,-10780 <== NOT EXECUTED
ffc24f6c: 7f a5 eb 78 mr r5,r29 <== NOT EXECUTED
ffc24f70: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc24f74: 48 00 5d d1 bl ffc2ad44 <printf> <== NOT EXECUTED
*available, size);
return 0;
}
ffc24f78: 80 01 00 34 lwz r0,52(r1)
ffc24f7c: 7f 63 db 78 mr r3,r27
ffc24f80: 81 81 00 18 lwz r12,24(r1)
ffc24f84: 7c 08 03 a6 mtlr r0
ffc24f88: 83 61 00 1c lwz r27,28(r1)
ffc24f8c: 83 81 00 20 lwz r28,32(r1)
ffc24f90: 7d 80 81 20 mtcrf 8,r12
ffc24f94: 83 a1 00 24 lwz r29,36(r1)
ffc24f98: 83 c1 00 28 lwz r30,40(r1)
ffc24f9c: 83 e1 00 2c lwz r31,44(r1)
ffc24fa0: 38 21 00 30 addi r1,r1,48
ffc24fa4: 4e 80 00 20 blr
if (rc > 0)
return rc;
}
if (read
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
ffc24fa8: 80 09 00 44 lwz r0,68(r9)
ffc24fac: 81 69 00 3c lwz r11,60(r9)
ffc24fb0: 2f 80 00 00 cmpwi cr7,r0,0
ffc24fb4: 40 9e 00 28 bne- cr7,ffc24fdc <rtems_rfs_file_io_start+0x12c><== NEVER TAKEN
ffc24fb8: 2f 8b 00 00 cmpwi cr7,r11,0
ffc24fbc: 40 9e 00 20 bne- cr7,ffc24fdc <rtems_rfs_file_io_start+0x12c><== ALWAYS TAKEN
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
ffc24fc0: 83 a9 00 40 lwz r29,64(r9)
ffc24fc4: 2f 9d 00 00 cmpwi cr7,r29,0
ffc24fc8: 40 be ff 74 bne- cr7,ffc24f3c <rtems_rfs_file_io_start+0x8c><== ALWAYS TAKEN
ffc24fcc: 4b ff ff 68 b ffc24f34 <rtems_rfs_file_io_start+0x84><== NOT EXECUTED
bool read)
{
size_t size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
ffc24fd0: 3c 80 ff c4 lis r4,-60 <== NOT EXECUTED
ffc24fd4: 38 84 be 90 addi r4,r4,-16752 <== NOT EXECUTED
ffc24fd8: 4b ff ff 30 b ffc24f08 <rtems_rfs_file_io_start+0x58><== NOT EXECUTED
if (rc > 0)
return rc;
}
if (read
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
ffc24fdc: 39 6b ff ff addi r11,r11,-1
ffc24fe0: 7f 80 58 00 cmpw cr7,r0,r11
ffc24fe4: 40 9e ff 50 bne+ cr7,ffc24f34 <rtems_rfs_file_io_start+0x84><== NEVER TAKEN
ffc24fe8: 4b ff ff d8 b ffc24fc0 <rtems_rfs_file_io_start+0x110>
bool request_read;
int rc;
request_read = read;
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
ffc24fec: 80 9f 00 1c lwz r4,28(r31)
ffc24ff0: 38 bf 00 10 addi r5,r31,16
ffc24ff4: 38 c1 00 08 addi r6,r1,8
ffc24ff8: 80 64 00 98 lwz r3,152(r4)
ffc24ffc: 38 84 00 34 addi r4,r4,52
ffc25000: 4b ff c9 75 bl ffc21974 <rtems_rfs_block_map_find>
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
ffc25004: 7c 7b 1b 79 mr. r27,r3
ffc25008: 40 81 00 1c ble- ffc25024 <rtems_rfs_file_io_start+0x174><== ALWAYS TAKEN
{
/*
* Has the read reached the EOF ?
*/
if (read && (rc == ENXIO))
ffc2500c: 2f 9b 00 06 cmpwi cr7,r27,6 <== NOT EXECUTED
ffc25010: 41 92 00 a0 beq- cr4,ffc250b0 <rtems_rfs_file_io_start+0x200><== NOT EXECUTED
ffc25014: 40 9e ff 64 bne+ cr7,ffc24f78 <rtems_rfs_file_io_start+0xc8><== NOT EXECUTED
{
*available = 0;
ffc25018: 93 9e 00 00 stw r28,0(r30) <== NOT EXECUTED
return 0;
ffc2501c: 3b 60 00 00 li r27,0 <== NOT EXECUTED
ffc25020: 4b ff ff 58 b ffc24f78 <rtems_rfs_file_io_start+0xc8><== NOT EXECUTED
/*
* If this is a write check if the write starts within a block or the
* amount of data is less than a block size. If it is read the block
* rather than getting a block to fill.
*/
if (!read &&
ffc25024: 40 92 00 30 bne- cr4,ffc25054 <rtems_rfs_file_io_start+0x1a4>
ffc25028: 80 1f 00 14 lwz r0,20(r31)
(rtems_rfs_file_block_offset (handle) ||
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
request_read = true;
ffc2502c: 3b a0 00 01 li r29,1
/*
* If this is a write check if the write starts within a block or the
* amount of data is less than a block size. If it is read the block
* rather than getting a block to fill.
*/
if (!read &&
ffc25030: 2f 80 00 00 cmpwi cr7,r0,0
ffc25034: 40 9e 00 20 bne- cr7,ffc25054 <rtems_rfs_file_io_start+0x1a4><== NEVER TAKEN
(rtems_rfs_file_block_offset (handle) ||
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
ffc25038: 81 3f 00 1c lwz r9,28(r31)
* If this is a write check if the write starts within a block or the
* amount of data is less than a block size. If it is read the block
* rather than getting a block to fill.
*/
if (!read &&
(rtems_rfs_file_block_offset (handle) ||
ffc2503c: 83 be 00 00 lwz r29,0(r30)
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
ffc25040: 81 29 00 98 lwz r9,152(r9)
* If this is a write check if the write starts within a block or the
* amount of data is less than a block size. If it is read the block
* rather than getting a block to fill.
*/
if (!read &&
(rtems_rfs_file_block_offset (handle) ||
ffc25044: 80 09 00 08 lwz r0,8(r9)
ffc25048: 7f a0 e8 10 subfc r29,r0,r29
ffc2504c: 7f bd e9 10 subfe r29,r29,r29
ffc25050: 7f bd 00 d0 neg r29,r29
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
request_read = true;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc25054: 38 60 00 20 li r3,32
ffc25058: 38 80 00 00 li r4,0
ffc2505c: 4b ff 29 0d bl ffc17968 <rtems_rfs_trace>
ffc25060: 2f 83 00 00 cmpwi cr7,r3,0
ffc25064: 41 9e 00 28 beq- cr7,ffc2508c <rtems_rfs_file_io_start+0x1dc><== ALWAYS TAKEN
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
ffc25068: 2f 9d 00 00 cmpwi cr7,r29,0 <== NOT EXECUTED
ffc2506c: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
ffc25070: 41 9e 00 80 beq- cr7,ffc250f0 <rtems_rfs_file_io_start+0x240><== NOT EXECUTED
ffc25074: 3c a0 ff c4 lis r5,-60 <== NOT EXECUTED
ffc25078: 38 a5 b9 38 addi r5,r5,-18120 <== NOT EXECUTED
ffc2507c: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc25080: 38 63 d5 ac addi r3,r3,-10836 <== NOT EXECUTED
ffc25084: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc25088: 48 00 5c bd bl ffc2ad44 <printf> <== NOT EXECUTED
block, request_read ? "yes" : "no");
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
ffc2508c: 81 3f 00 1c lwz r9,28(r31)
ffc25090: 38 9f 00 04 addi r4,r31,4
ffc25094: 80 a1 00 08 lwz r5,8(r1)
ffc25098: 7f a6 eb 78 mr r6,r29
ffc2509c: 80 69 00 98 lwz r3,152(r9)
ffc250a0: 4b ff d7 b5 bl ffc22854 <rtems_rfs_buffer_handle_request>
rtems_rfs_file_buffer (handle),
block, request_read);
if (rc > 0)
ffc250a4: 7c 7b 1b 79 mr. r27,r3
ffc250a8: 41 81 fe d0 bgt+ ffc24f78 <rtems_rfs_file_io_start+0xc8><== NEVER TAKEN
ffc250ac: 4b ff fe 80 b ffc24f2c <rtems_rfs_file_io_start+0x7c>
{
*available = 0;
return 0;
}
if (rc != ENXIO)
ffc250b0: 40 9e fe c8 bne+ cr7,ffc24f78 <rtems_rfs_file_io_start+0xc8><== NOT EXECUTED
return rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc250b4: 38 60 00 20 li r3,32 <== NOT EXECUTED
ffc250b8: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc250bc: 4b ff 28 ad bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc250c0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc250c4: 40 9e 00 38 bne- cr7,ffc250fc <rtems_rfs_file_io_start+0x24c><== NOT EXECUTED
printf ("rtems-rfs: file-io: start: grow\n");
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
ffc250c8: 80 9f 00 1c lwz r4,28(r31) <== NOT EXECUTED
ffc250cc: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc250d0: 38 c1 00 08 addi r6,r1,8 <== NOT EXECUTED
ffc250d4: 80 64 00 98 lwz r3,152(r4) <== NOT EXECUTED
ffc250d8: 38 84 00 34 addi r4,r4,52 <== NOT EXECUTED
rtems_rfs_file_map (handle),
1, &block);
if (rc > 0)
return rc;
request_read = false;
ffc250dc: 3b a0 00 00 li r29,0 <== NOT EXECUTED
return rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: start: grow\n");
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
ffc250e0: 4b ff cb 41 bl ffc21c20 <rtems_rfs_block_map_grow> <== NOT EXECUTED
rtems_rfs_file_map (handle),
1, &block);
if (rc > 0)
ffc250e4: 7c 7b 1b 79 mr. r27,r3 <== NOT EXECUTED
ffc250e8: 41 81 fe 90 bgt+ ffc24f78 <rtems_rfs_file_io_start+0xc8><== NOT EXECUTED
ffc250ec: 4b ff ff 68 b ffc25054 <rtems_rfs_file_io_start+0x1a4><== NOT EXECUTED
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
request_read = true;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
ffc250f0: 3c a0 ff c4 lis r5,-60 <== NOT EXECUTED
ffc250f4: 38 a5 be 14 addi r5,r5,-16876 <== NOT EXECUTED
ffc250f8: 4b ff ff 84 b ffc2507c <rtems_rfs_file_io_start+0x1cc><== NOT EXECUTED
if (rc != ENXIO)
return rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: start: grow\n");
ffc250fc: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc25100: 38 63 d5 8c addi r3,r3,-10868 <== NOT EXECUTED
ffc25104: 48 00 5d f5 bl ffc2aef8 <puts> <== NOT EXECUTED
ffc25108: 4b ff ff c0 b ffc250c8 <rtems_rfs_file_io_start+0x218><== NOT EXECUTED
ffc24774 <rtems_rfs_file_open>:
int
rtems_rfs_file_open (rtems_rfs_file_system* fs,
rtems_rfs_ino ino,
uint32_t flags,
rtems_rfs_file_handle** file)
{
ffc24774: 94 21 ff d8 stwu r1,-40(r1)
ffc24778: 7c 08 02 a6 mflr r0
ffc2477c: 93 61 00 14 stw r27,20(r1)
ffc24780: 7c 7b 1b 78 mr r27,r3
rtems_rfs_file_handle* handle;
rtems_rfs_file_shared* shared;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
ffc24784: 38 60 00 08 li r3,8
int
rtems_rfs_file_open (rtems_rfs_file_system* fs,
rtems_rfs_ino ino,
uint32_t flags,
rtems_rfs_file_handle** file)
{
ffc24788: 93 a1 00 1c stw r29,28(r1)
ffc2478c: 7c 9d 23 78 mr r29,r4
rtems_rfs_file_handle* handle;
rtems_rfs_file_shared* shared;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
ffc24790: 38 80 00 00 li r4,0
int
rtems_rfs_file_open (rtems_rfs_file_system* fs,
rtems_rfs_ino ino,
uint32_t flags,
rtems_rfs_file_handle** file)
{
ffc24794: 93 41 00 10 stw r26,16(r1)
ffc24798: 7c ba 2b 78 mr r26,r5
ffc2479c: 93 81 00 18 stw r28,24(r1)
ffc247a0: 7c dc 33 78 mr r28,r6
ffc247a4: 90 01 00 2c stw r0,44(r1)
ffc247a8: 93 01 00 08 stw r24,8(r1)
ffc247ac: 93 21 00 0c stw r25,12(r1)
ffc247b0: 93 c1 00 20 stw r30,32(r1)
ffc247b4: 93 e1 00 24 stw r31,36(r1)
rtems_rfs_file_handle* handle;
rtems_rfs_file_shared* shared;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
ffc247b8: 4b ff 31 b1 bl ffc17968 <rtems_rfs_trace>
ffc247bc: 2f 83 00 00 cmpwi cr7,r3,0
ffc247c0: 40 9e 00 d4 bne- cr7,ffc24894 <rtems_rfs_file_open+0x120><== NEVER TAKEN
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
*file = NULL;
ffc247c4: 3b 20 00 00 li r25,0
ffc247c8: 93 3c 00 00 stw r25,0(r28)
/*
* Allocate a new handle and initialise it. Do this before we deal with the
* shared node data so we do not have to be concerned with reference
* counting.
*/
handle = malloc (sizeof (rtems_rfs_file_handle));
ffc247cc: 38 60 00 20 li r3,32
if (!handle)
return ENOMEM;
ffc247d0: 3b 00 00 0c li r24,12
/*
* Allocate a new handle and initialise it. Do this before we deal with the
* shared node data so we do not have to be concerned with reference
* counting.
*/
handle = malloc (sizeof (rtems_rfs_file_handle));
ffc247d4: 4b fe 46 19 bl ffc08dec <malloc>
if (!handle)
ffc247d8: 7c 7e 1b 79 mr. r30,r3
ffc247dc: 41 82 00 84 beq- ffc24860 <rtems_rfs_file_open+0xec> <== NEVER TAKEN
return ENOMEM;
memset (handle, 0, sizeof (rtems_rfs_file_handle));
ffc247e0: 93 3e 00 04 stw r25,4(r30)
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
ffc247e4: 39 3b 00 74 addi r9,r27,116
ffc247e8: 93 3e 00 00 stw r25,0(r30)
ffc247ec: 93 3e 00 10 stw r25,16(r30)
ffc247f0: 93 3e 00 14 stw r25,20(r30)
ffc247f4: 93 3e 00 18 stw r25,24(r30)
ffc247f8: 93 3e 00 1c stw r25,28(r30)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc247fc: 83 fb 00 70 lwz r31,112(r27)
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc24800: 9b 3e 00 04 stb r25,4(r30)
rtems_rfs_file_get_shared (rtems_rfs_file_system* fs,
rtems_rfs_ino ino)
{
rtems_chain_node* node;
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
ffc24804: 7f 9f 48 00 cmpw cr7,r31,r9
handle->bnum = 0;
ffc24808: 93 3e 00 08 stw r25,8(r30)
handle->buffer = NULL;
ffc2480c: 93 3e 00 0c stw r25,12(r30)
ffc24810: 40 be 00 14 bne+ cr7,ffc24824 <rtems_rfs_file_open+0xb0><== NEVER TAKEN
ffc24814: 48 00 00 c0 b ffc248d4 <rtems_rfs_file_open+0x160>
if (shared->inode.ino == ino)
return shared;
node = rtems_chain_next (node);
}
return NULL;
}
ffc24818: 83 ff 00 00 lwz r31,0(r31) <== NOT EXECUTED
rtems_rfs_file_get_shared (rtems_rfs_file_system* fs,
rtems_rfs_ino ino)
{
rtems_chain_node* node;
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
ffc2481c: 7f 9f 48 00 cmpw cr7,r31,r9 <== NOT EXECUTED
ffc24820: 41 9e 00 b4 beq- cr7,ffc248d4 <rtems_rfs_file_open+0x160><== NOT EXECUTED
{
rtems_rfs_file_shared* shared;
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
ffc24824: 80 1f 00 14 lwz r0,20(r31) <== NOT EXECUTED
ffc24828: 7f 9d 00 00 cmpw cr7,r29,r0 <== NOT EXECUTED
ffc2482c: 40 9e ff ec bne+ cr7,ffc24818 <rtems_rfs_file_open+0xa4><== NOT EXECUTED
* the reference count and return the pointer to the data.
*/
shared = rtems_rfs_file_get_shared (fs, ino);
if (shared)
{
shared->references++;
ffc24830: 81 3f 00 08 lwz r9,8(r31) <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
ffc24834: 38 60 00 08 li r3,8 <== NOT EXECUTED
ffc24838: 38 80 00 00 li r4,0 <== NOT EXECUTED
* the reference count and return the pointer to the data.
*/
shared = rtems_rfs_file_get_shared (fs, ino);
if (shared)
{
shared->references++;
ffc2483c: 38 09 00 01 addi r0,r9,1 <== NOT EXECUTED
ffc24840: 90 1f 00 08 stw r0,8(r31) <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
ffc24844: 4b ff 31 25 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc24848: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc2484c: 40 9e 00 60 bne- cr7,ffc248ac <rtems_rfs_file_open+0x138><== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
}
handle->flags = flags;
ffc24850: 93 5e 00 00 stw r26,0(r30)
handle->shared = shared;
*file = handle;
return 0;
ffc24854: 3b 00 00 00 li r24,0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
}
handle->flags = flags;
handle->shared = shared;
ffc24858: 93 fe 00 1c stw r31,28(r30)
*file = handle;
ffc2485c: 93 dc 00 00 stw r30,0(r28)
return 0;
}
ffc24860: 80 01 00 2c lwz r0,44(r1)
ffc24864: 7f 03 c3 78 mr r3,r24
ffc24868: 83 21 00 0c lwz r25,12(r1)
ffc2486c: 7c 08 03 a6 mtlr r0
ffc24870: 83 01 00 08 lwz r24,8(r1)
ffc24874: 83 41 00 10 lwz r26,16(r1)
ffc24878: 83 61 00 14 lwz r27,20(r1)
ffc2487c: 83 81 00 18 lwz r28,24(r1)
ffc24880: 83 a1 00 1c lwz r29,28(r1)
ffc24884: 83 c1 00 20 lwz r30,32(r1)
ffc24888: 83 e1 00 24 lwz r31,36(r1)
ffc2488c: 38 21 00 28 addi r1,r1,40
ffc24890: 4e 80 00 20 blr
rtems_rfs_file_handle* handle;
rtems_rfs_file_shared* shared;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
ffc24894: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc24898: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc2489c: 38 63 d3 b4 addi r3,r3,-11340 <== NOT EXECUTED
ffc248a0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc248a4: 48 00 64 a1 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc248a8: 4b ff ff 1c b ffc247c4 <rtems_rfs_file_open+0x50> <== NOT EXECUTED
shared = rtems_rfs_file_get_shared (fs, ino);
if (shared)
{
shared->references++;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: ino=%" PRId32 " shared\n", ino);
ffc248ac: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc248b0: 38 63 d3 d4 addi r3,r3,-11308 <== NOT EXECUTED
ffc248b4: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc248b8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc248bc: 48 00 64 89 bl ffc2ad44 <printf> <== NOT EXECUTED
handle->flags = flags;
handle->shared = shared;
*file = handle;
return 0;
ffc248c0: 3b 00 00 00 li r24,0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
}
handle->flags = flags;
ffc248c4: 93 5e 00 00 stw r26,0(r30) <== NOT EXECUTED
handle->shared = shared;
ffc248c8: 93 fe 00 1c stw r31,28(r30) <== NOT EXECUTED
*file = handle;
ffc248cc: 93 dc 00 00 stw r30,0(r28) <== NOT EXECUTED
ffc248d0: 4b ff ff 90 b ffc24860 <rtems_rfs_file_open+0xec> <== NOT EXECUTED
{
/*
* None exists so create. Copy in the shared parts of the inode we hold in
* memory.
*/
shared = malloc (sizeof (rtems_rfs_file_shared));
ffc248d4: 38 60 00 9c li r3,156
ffc248d8: 4b fe 45 15 bl ffc08dec <malloc>
if (!shared)
ffc248dc: 7c 7f 1b 79 mr. r31,r3
ffc248e0: 41 82 00 f4 beq- ffc249d4 <rtems_rfs_file_open+0x260> <== NEVER TAKEN
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return ENOMEM;
}
memset (shared, 0, sizeof (rtems_rfs_file_shared));
ffc248e4: 38 80 00 00 li r4,0
ffc248e8: 38 a0 00 9c li r5,156
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
ffc248ec: 3b 3f 00 0c addi r25,r31,12
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return ENOMEM;
}
memset (shared, 0, sizeof (rtems_rfs_file_shared));
ffc248f0: 48 00 62 c5 bl ffc2abb4 <memset>
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
ffc248f4: 7f 63 db 78 mr r3,r27
ffc248f8: 7f a4 eb 78 mr r4,r29
ffc248fc: 7f 25 cb 78 mr r5,r25
ffc24900: 38 c0 00 01 li r6,1
ffc24904: 4b fe f6 d5 bl ffc13fd8 <rtems_rfs_inode_open>
if (rc > 0)
ffc24908: 7c 78 1b 79 mr. r24,r3
ffc2490c: 40 81 00 6c ble- ffc24978 <rtems_rfs_file_open+0x204> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
ffc24910: 38 60 00 08 li r3,8 <== NOT EXECUTED
ffc24914: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc24918: 4b ff 30 51 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc2491c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc24920: 41 be 00 24 beq+ cr7,ffc24944 <rtems_rfs_file_open+0x1d0><== NOT EXECUTED
printf ("rtems-rfs: file-open: inode open failed: %d: %s\n",
ffc24924: 7f 03 c3 78 mr r3,r24 <== NOT EXECUTED
ffc24928: 48 00 71 89 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc2492c: 7f 04 c3 78 mr r4,r24 <== NOT EXECUTED
ffc24930: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc24934: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc24938: 38 63 d3 fc addi r3,r3,-11268 <== NOT EXECUTED
ffc2493c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc24940: 48 00 64 05 bl ffc2ad44 <printf> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
rc, strerror (rc));
rtems_rfs_inode_close (fs, &shared->inode);
free (shared);
ffc24944: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc24948: 4b fe 3b 99 bl ffc084e0 <free> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc2494c: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc24950: 38 9e 00 04 addi r4,r30,4 <== NOT EXECUTED
ffc24954: 4b ff dc ed bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
ffc24958: 38 00 00 00 li r0,0 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc2495c: 39 20 00 00 li r9,0 <== NOT EXECUTED
handle->bnum = 0;
ffc24960: 90 1e 00 08 stw r0,8(r30) <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
ffc24964: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc24968: 99 3e 00 04 stb r9,4(r30) <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
ffc2496c: 90 1e 00 0c stw r0,12(r30) <== NOT EXECUTED
ffc24970: 4b fe 3b 71 bl ffc084e0 <free> <== NOT EXECUTED
return rc;
ffc24974: 4b ff fe ec b ffc24860 <rtems_rfs_file_open+0xec> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return rc;
}
rc = rtems_rfs_block_map_open (fs, &shared->inode, &shared->map);
ffc24978: 7f 63 db 78 mr r3,r27
ffc2497c: 7f 24 cb 78 mr r4,r25
ffc24980: 38 bf 00 34 addi r5,r31,52
ffc24984: 4b ff cb d5 bl ffc21558 <rtems_rfs_block_map_open>
if (rc > 0)
ffc24988: 7c 78 1b 79 mr. r24,r3
ffc2498c: 40 81 00 70 ble- ffc249fc <rtems_rfs_file_open+0x288> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
ffc24990: 38 60 00 08 li r3,8 <== NOT EXECUTED
ffc24994: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc24998: 4b ff 2f d1 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc2499c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc249a0: 41 be 00 24 beq+ cr7,ffc249c4 <rtems_rfs_file_open+0x250><== NOT EXECUTED
printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
ffc249a4: 7f 03 c3 78 mr r3,r24 <== NOT EXECUTED
ffc249a8: 48 00 71 09 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc249ac: 7f 04 c3 78 mr r4,r24 <== NOT EXECUTED
ffc249b0: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc249b4: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc249b8: 38 63 d4 30 addi r3,r3,-11216 <== NOT EXECUTED
ffc249bc: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc249c0: 48 00 63 85 bl ffc2ad44 <printf> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &shared->inode);
ffc249c4: 7f 24 cb 78 mr r4,r25 <== NOT EXECUTED
ffc249c8: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc249cc: 4b fe f8 6d bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
ffc249d0: 4b ff ff 74 b ffc24944 <rtems_rfs_file_open+0x1d0> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc249d4: 38 9e 00 04 addi r4,r30,4 <== NOT EXECUTED
ffc249d8: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc249dc: 4b ff dc 65 bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
ffc249e0: 9b fe 00 04 stb r31,4(r30) <== NOT EXECUTED
*/
shared = malloc (sizeof (rtems_rfs_file_shared));
if (!shared)
{
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
ffc249e4: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
handle->bnum = 0;
ffc249e8: 93 fe 00 08 stw r31,8(r30) <== NOT EXECUTED
return ENOMEM;
ffc249ec: 3b 00 00 0c li r24,12 <== NOT EXECUTED
handle->buffer = NULL;
ffc249f0: 93 fe 00 0c stw r31,12(r30) <== NOT EXECUTED
*/
shared = malloc (sizeof (rtems_rfs_file_shared));
if (!shared)
{
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
ffc249f4: 4b fe 3a ed bl ffc084e0 <free> <== NOT EXECUTED
return ENOMEM;
ffc249f8: 4b ff fe 68 b ffc24860 <rtems_rfs_file_open+0xec> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return rc;
}
shared->references = 1;
ffc249fc: 38 00 00 01 li r0,1
if (shared->inode.ino == ino)
return shared;
node = rtems_chain_next (node);
}
return NULL;
}
ffc24a00: 81 3f 00 18 lwz r9,24(r31)
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return rc;
}
shared->references = 1;
ffc24a04: 90 1f 00 08 stw r0,8(r31)
ffc24a08: 38 7b 00 70 addi r3,r27,112
ffc24a0c: 7f e4 fb 78 mr r4,r31
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
ffc24a10: 89 09 00 0c lbz r8,12(r9)
ffc24a14: 89 49 00 0d lbz r10,13(r9)
ffc24a18: 89 69 00 0f lbz r11,15(r9)
ffc24a1c: 55 08 c0 0e rlwinm r8,r8,24,0,7
ffc24a20: 88 09 00 0e lbz r0,14(r9)
ffc24a24: 55 4a 80 1e rlwinm r10,r10,16,0,15
ffc24a28: 7d 0a 53 78 or r10,r8,r10
ffc24a2c: 7d 4b 5b 78 or r11,r10,r11
ffc24a30: 54 00 40 2e rlwinm r0,r0,8,0,23
ffc24a34: 7d 60 03 78 or r0,r11,r0
shared->size.count = rtems_rfs_inode_get_block_count (&shared->inode);
ffc24a38: 90 1f 00 84 stw r0,132(r31)
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
ffc24a3c: 89 69 00 0a lbz r11,10(r9)
ffc24a40: 88 09 00 0b lbz r0,11(r9)
ffc24a44: 55 6b 40 2e rlwinm r11,r11,8,0,23
shared->size.offset = rtems_rfs_inode_get_block_offset (&shared->inode);
ffc24a48: 7d 60 03 78 or r0,r11,r0
ffc24a4c: 90 1f 00 88 stw r0,136(r31)
* @return rtems_rfs_time The atime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_atime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->atime);
ffc24a50: 89 09 00 10 lbz r8,16(r9)
ffc24a54: 89 49 00 11 lbz r10,17(r9)
ffc24a58: 89 69 00 13 lbz r11,19(r9)
ffc24a5c: 55 08 c0 0e rlwinm r8,r8,24,0,7
ffc24a60: 88 09 00 12 lbz r0,18(r9)
ffc24a64: 55 4a 80 1e rlwinm r10,r10,16,0,15
ffc24a68: 7d 0a 53 78 or r10,r8,r10
ffc24a6c: 7d 4b 5b 78 or r11,r10,r11
ffc24a70: 54 00 40 2e rlwinm r0,r0,8,0,23
ffc24a74: 7d 60 03 78 or r0,r11,r0
shared->atime = rtems_rfs_inode_get_atime (&shared->inode);
ffc24a78: 90 1f 00 8c stw r0,140(r31)
* @return rtems_rfs_time The mtime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_mtime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->mtime);
ffc24a7c: 89 09 00 14 lbz r8,20(r9)
ffc24a80: 89 49 00 15 lbz r10,21(r9)
ffc24a84: 89 69 00 17 lbz r11,23(r9)
ffc24a88: 55 08 c0 0e rlwinm r8,r8,24,0,7
ffc24a8c: 88 09 00 16 lbz r0,22(r9)
ffc24a90: 55 4a 80 1e rlwinm r10,r10,16,0,15
ffc24a94: 7d 0a 53 78 or r10,r8,r10
ffc24a98: 7d 4b 5b 78 or r11,r10,r11
ffc24a9c: 54 00 40 2e rlwinm r0,r0,8,0,23
ffc24aa0: 7d 60 03 78 or r0,r11,r0
shared->mtime = rtems_rfs_inode_get_mtime (&shared->inode);
ffc24aa4: 90 1f 00 90 stw r0,144(r31)
* @return rtems_rfs_time The ctime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_ctime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->ctime);
ffc24aa8: 89 09 00 19 lbz r8,25(r9)
ffc24aac: 89 49 00 18 lbz r10,24(r9)
ffc24ab0: 89 69 00 1b lbz r11,27(r9)
ffc24ab4: 88 09 00 1a lbz r0,26(r9)
ffc24ab8: 55 4a c0 0e rlwinm r10,r10,24,0,7
ffc24abc: 55 09 80 1e rlwinm r9,r8,16,0,15
shared->ctime = rtems_rfs_inode_get_ctime (&shared->inode);
shared->fs = fs;
ffc24ac0: 93 7f 00 98 stw r27,152(r31)
ffc24ac4: 7d 49 4b 78 or r9,r10,r9
ffc24ac8: 7d 29 5b 78 or r9,r9,r11
ffc24acc: 54 00 40 2e rlwinm r0,r0,8,0,23
ffc24ad0: 7d 20 03 78 or r0,r9,r0
shared->references = 1;
shared->size.count = rtems_rfs_inode_get_block_count (&shared->inode);
shared->size.offset = rtems_rfs_inode_get_block_offset (&shared->inode);
shared->atime = rtems_rfs_inode_get_atime (&shared->inode);
shared->mtime = rtems_rfs_inode_get_mtime (&shared->inode);
shared->ctime = rtems_rfs_inode_get_ctime (&shared->inode);
ffc24ad4: 90 1f 00 94 stw r0,148(r31)
ffc24ad8: 4b fe 9c d1 bl ffc0e7a8 <_Chain_Append>
shared->fs = fs;
rtems_chain_append (&fs->file_shares, &shared->link);
rtems_rfs_inode_unload (fs, &shared->inode, false);
ffc24adc: 7f 24 cb 78 mr r4,r25
ffc24ae0: 38 a0 00 00 li r5,0
ffc24ae4: 7f 63 db 78 mr r3,r27
ffc24ae8: 4b fe f6 11 bl ffc140f8 <rtems_rfs_inode_unload>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
ffc24aec: 38 60 00 08 li r3,8
ffc24af0: 38 80 00 00 li r4,0
ffc24af4: 4b ff 2e 75 bl ffc17968 <rtems_rfs_trace>
ffc24af8: 2f 83 00 00 cmpwi cr7,r3,0
ffc24afc: 41 9e fd 54 beq+ cr7,ffc24850 <rtems_rfs_file_open+0xdc><== ALWAYS TAKEN
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
ffc24b00: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc24b04: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc24b08: 38 63 d4 68 addi r3,r3,-11160 <== NOT EXECUTED
ffc24b0c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc24b10: 48 00 62 35 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc24b14: 4b ff fd 3c b ffc24850 <rtems_rfs_file_open+0xdc> <== NOT EXECUTED
ffc25460 <rtems_rfs_file_seek>:
int
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
rtems_rfs_pos pos,
rtems_rfs_pos* new_pos)
{
ffc25460: 94 21 ff e8 stwu r1,-24(r1)
ffc25464: 7c 08 02 a6 mflr r0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc25468: 38 80 00 00 li r4,0
int
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
rtems_rfs_pos pos,
rtems_rfs_pos* new_pos)
{
ffc2546c: 93 81 00 08 stw r28,8(r1)
ffc25470: 7c 7c 1b 78 mr r28,r3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc25474: 38 60 00 20 li r3,32
int
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
rtems_rfs_pos pos,
rtems_rfs_pos* new_pos)
{
ffc25478: 93 a1 00 0c stw r29,12(r1)
ffc2547c: 7c dd 33 78 mr r29,r6
ffc25480: 93 c1 00 10 stw r30,16(r1)
ffc25484: 7c fe 3b 78 mr r30,r7
ffc25488: 93 e1 00 14 stw r31,20(r1)
ffc2548c: 7c bf 2b 78 mr r31,r5
ffc25490: 90 01 00 1c stw r0,28(r1)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc25494: 4b ff 24 d5 bl ffc17968 <rtems_rfs_trace>
ffc25498: 2f 83 00 00 cmpwi cr7,r3,0
ffc2549c: 40 9e 00 9c bne- cr7,ffc25538 <rtems_rfs_file_seek+0xd8><== NEVER TAKEN
* file, this function does not itself extend the size of the file."
*
* This means the file needs to set the file size to the pos only when a
* write occurs.
*/
if (pos < rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
ffc254a0: 80 9c 00 1c lwz r4,28(r28)
ffc254a4: 80 64 00 98 lwz r3,152(r4)
ffc254a8: 38 84 00 84 addi r4,r4,132
ffc254ac: 4b ff c0 55 bl ffc21500 <rtems_rfs_block_get_size>
ffc254b0: 7f 83 f8 40 cmplw cr7,r3,r31
ffc254b4: 41 9d 00 40 bgt- cr7,ffc254f4 <rtems_rfs_file_seek+0x94><== NEVER TAKEN
ffc254b8: 7f 83 f8 00 cmpw cr7,r3,r31
ffc254bc: 41 9e 00 30 beq- cr7,ffc254ec <rtems_rfs_file_seek+0x8c><== ALWAYS TAKEN
handle->shared))
rtems_rfs_file_set_bpos (handle, pos);
*new_pos = pos;
return 0;
}
ffc254c0: 80 01 00 1c lwz r0,28(r1)
ffc254c4: 38 60 00 00 li r3,0
*/
if (pos < rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
handle->shared))
rtems_rfs_file_set_bpos (handle, pos);
*new_pos = pos;
ffc254c8: 93 fe 00 00 stw r31,0(r30)
return 0;
}
ffc254cc: 7c 08 03 a6 mtlr r0
*/
if (pos < rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
handle->shared))
rtems_rfs_file_set_bpos (handle, pos);
*new_pos = pos;
ffc254d0: 93 be 00 04 stw r29,4(r30)
return 0;
}
ffc254d4: 83 81 00 08 lwz r28,8(r1)
ffc254d8: 83 a1 00 0c lwz r29,12(r1)
ffc254dc: 83 c1 00 10 lwz r30,16(r1)
ffc254e0: 83 e1 00 14 lwz r31,20(r1)
ffc254e4: 38 21 00 18 addi r1,r1,24
ffc254e8: 4e 80 00 20 blr
* file, this function does not itself extend the size of the file."
*
* This means the file needs to set the file size to the pos only when a
* write occurs.
*/
if (pos < rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
ffc254ec: 7f 84 e8 40 cmplw cr7,r4,r29
ffc254f0: 40 9d ff d0 ble+ cr7,ffc254c0 <rtems_rfs_file_seek+0x60><== ALWAYS TAKEN
handle->shared))
rtems_rfs_file_set_bpos (handle, pos);
ffc254f4: 81 3c 00 1c lwz r9,28(r28) <== NOT EXECUTED
ffc254f8: 7f e5 fb 78 mr r5,r31 <== NOT EXECUTED
ffc254fc: 7f a6 eb 78 mr r6,r29 <== NOT EXECUTED
ffc25500: 80 69 00 98 lwz r3,152(r9) <== NOT EXECUTED
ffc25504: 38 fc 00 10 addi r7,r28,16 <== NOT EXECUTED
ffc25508: 4b ff be b1 bl ffc213b8 <rtems_rfs_block_get_bpos> <== NOT EXECUTED
*new_pos = pos;
return 0;
}
ffc2550c: 80 01 00 1c lwz r0,28(r1) <== NOT EXECUTED
*/
if (pos < rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
handle->shared))
rtems_rfs_file_set_bpos (handle, pos);
*new_pos = pos;
ffc25510: 93 fe 00 00 stw r31,0(r30) <== NOT EXECUTED
return 0;
}
ffc25514: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc25518: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
*/
if (pos < rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
handle->shared))
rtems_rfs_file_set_bpos (handle, pos);
*new_pos = pos;
ffc2551c: 93 be 00 04 stw r29,4(r30) <== NOT EXECUTED
return 0;
}
ffc25520: 83 81 00 08 lwz r28,8(r1) <== NOT EXECUTED
ffc25524: 83 a1 00 0c lwz r29,12(r1) <== NOT EXECUTED
ffc25528: 83 c1 00 10 lwz r30,16(r1) <== NOT EXECUTED
ffc2552c: 83 e1 00 14 lwz r31,20(r1) <== NOT EXECUTED
ffc25530: 38 21 00 18 addi r1,r1,24 <== NOT EXECUTED
ffc25534: 4e 80 00 20 blr <== NOT EXECUTED
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
rtems_rfs_pos pos,
rtems_rfs_pos* new_pos)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-seek: new=%" PRIu64 "\n", pos);
ffc25538: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc2553c: 7f e5 fb 78 mr r5,r31 <== NOT EXECUTED
ffc25540: 7f a6 eb 78 mr r6,r29 <== NOT EXECUTED
ffc25544: 38 63 d6 b4 addi r3,r3,-10572 <== NOT EXECUTED
ffc25548: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc2554c: 48 00 57 f9 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc25550: 4b ff ff 50 b ffc254a0 <rtems_rfs_file_seek+0x40> <== NOT EXECUTED
ffc25554 <rtems_rfs_file_set_size>:
}
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
ffc25554: 94 21 ff b0 stwu r1,-80(r1)
ffc25558: 7c 08 02 a6 mflr r0
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
rtems_rfs_pos size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc2555c: 38 80 00 00 li r4,0
}
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
ffc25560: 90 01 00 54 stw r0,84(r1)
ffc25564: 93 21 00 34 stw r25,52(r1)
ffc25568: 7c 79 1b 78 mr r25,r3
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
rtems_rfs_pos size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc2556c: 38 60 00 20 li r3,32
}
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
ffc25570: 92 e1 00 2c stw r23,44(r1)
ffc25574: 93 01 00 30 stw r24,48(r1)
ffc25578: 93 41 00 38 stw r26,56(r1)
ffc2557c: 7c ba 2b 78 mr r26,r5
ffc25580: 93 61 00 3c stw r27,60(r1)
ffc25584: 7c db 33 78 mr r27,r6
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
ffc25588: 83 19 00 1c lwz r24,28(r25)
}
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
ffc2558c: 92 61 00 1c stw r19,28(r1)
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
ffc25590: 3a f8 00 34 addi r23,r24,52
}
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
ffc25594: 92 81 00 20 stw r20,32(r1)
ffc25598: 92 a1 00 24 stw r21,36(r1)
ffc2559c: 92 c1 00 28 stw r22,40(r1)
ffc255a0: 93 81 00 40 stw r28,64(r1)
ffc255a4: 93 a1 00 44 stw r29,68(r1)
ffc255a8: 93 c1 00 48 stw r30,72(r1)
ffc255ac: 93 e1 00 4c stw r31,76(r1)
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
rtems_rfs_pos size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc255b0: 4b ff 23 b9 bl ffc17968 <rtems_rfs_trace>
ffc255b4: 2f 83 00 00 cmpwi cr7,r3,0
ffc255b8: 40 9e 02 10 bne- cr7,ffc257c8 <rtems_rfs_file_set_size+0x274><== NEVER TAKEN
printf ("rtems-rfs: file-set-size: size=%" PRIu64 "\n", new_size);
/*
* Short cut for the common truncate on open call.
*/
if (new_size == 0)
ffc255bc: 7f 40 db 79 or. r0,r26,r27
ffc255c0: 40 82 00 64 bne- ffc25624 <rtems_rfs_file_set_size+0xd0>
{
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
ffc255c4: 81 39 00 1c lwz r9,28(r25)
ffc255c8: 7e e4 bb 78 mr r4,r23
ffc255cc: 80 69 00 98 lwz r3,152(r9)
ffc255d0: 4b ff ce 09 bl ffc223d8 <rtems_rfs_block_map_free_all>
if (rc > 0)
ffc255d4: 7c 76 1b 79 mr. r22,r3
ffc255d8: 40 81 01 bc ble- ffc25794 <rtems_rfs_file_set_size+0x240><== ALWAYS TAKEN
if (rtems_rfs_file_update_mtime (handle))
handle->shared->mtime = time (NULL);
return 0;
}
ffc255dc: 80 01 00 54 lwz r0,84(r1)
ffc255e0: 7e c3 b3 78 mr r3,r22
ffc255e4: 82 61 00 1c lwz r19,28(r1)
ffc255e8: 7c 08 03 a6 mtlr r0
ffc255ec: 82 81 00 20 lwz r20,32(r1)
ffc255f0: 82 a1 00 24 lwz r21,36(r1)
ffc255f4: 82 c1 00 28 lwz r22,40(r1)
ffc255f8: 82 e1 00 2c lwz r23,44(r1)
ffc255fc: 83 01 00 30 lwz r24,48(r1)
ffc25600: 83 21 00 34 lwz r25,52(r1)
ffc25604: 83 41 00 38 lwz r26,56(r1)
ffc25608: 83 61 00 3c lwz r27,60(r1)
ffc2560c: 83 81 00 40 lwz r28,64(r1)
ffc25610: 83 a1 00 44 lwz r29,68(r1)
ffc25614: 83 c1 00 48 lwz r30,72(r1)
ffc25618: 83 e1 00 4c lwz r31,76(r1)
ffc2561c: 38 21 00 50 addi r1,r1,80
ffc25620: 4e 80 00 20 blr
if (rc > 0)
return rc;
}
else
{
size = rtems_rfs_file_size (handle);
ffc25624: 80 99 00 1c lwz r4,28(r25)
ffc25628: 80 64 00 98 lwz r3,152(r4)
ffc2562c: 38 84 00 84 addi r4,r4,132
ffc25630: 4b ff be d1 bl ffc21500 <rtems_rfs_block_get_size>
/*
* If the file is same size do nothing else grow or shrink it ?
*/
if (size != new_size)
ffc25634: 7f 9a 18 00 cmpw cr7,r26,r3
ffc25638: 41 9e 01 54 beq- cr7,ffc2578c <rtems_rfs_file_set_size+0x238><== ALWAYS TAKEN
{
if (size < new_size)
ffc2563c: 7f 1a 18 40 cmplw cr6,r26,r3
ffc25640: 40 99 01 a4 ble- cr6,ffc257e4 <rtems_rfs_file_set_size+0x290><== ALWAYS TAKEN
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
ffc25644: 82 b9 00 1c lwz r21,28(r25)
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
ffc25648: 7f e4 d8 10 subfc r31,r4,r27
ffc2564c: 7f c3 d1 10 subfe r30,r3,r26
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
read_block = false;
while (count)
ffc25650: 7f c0 fb 79 or. r0,r30,r31
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
ffc25654: 81 35 00 98 lwz r9,152(r21)
ffc25658: 7e b6 ab 78 mr r22,r21
ffc2565c: 83 49 00 08 lwz r26,8(r9)
read_block = false;
while (count)
ffc25660: 41 82 01 38 beq- ffc25798 <rtems_rfs_file_set_size+0x244><== NEVER TAKEN
ffc25664: 3a 60 00 00 li r19,0
/*
* Get the block position for the current end of the file as seen by
* the map. If not found and the EOF grow the map then fill the block
* with 0.
*/
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos);
ffc25668: 3b 60 00 00 li r27,0
ffc2566c: 3a 80 00 01 li r20,1
}
/*
* Only read the block if the length is not the block size.
*/
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
ffc25670: 3a b9 00 04 addi r21,r25,4
ffc25674: 48 00 00 94 b ffc25708 <rtems_rfs_file_set_size+0x1b4>
map, 1, &block);
if (rc > 0)
return rc;
}
if (count < (length - bpos.boff))
ffc25678: 7f 89 f8 40 cmplw cr7,r9,r31
ffc2567c: 40 9d 01 04 ble- cr7,ffc25780 <rtems_rfs_file_set_size+0x22c><== NEVER TAKEN
{
length = count + bpos.boff;
ffc25680: 7f 40 fa 14 add r26,r0,r31
ffc25684: 9a 98 00 34 stb r20,52(r24)
read_block = true;
ffc25688: 3a 60 00 01 li r19,1
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
ffc2568c: 93 58 00 40 stw r26,64(r24)
}
/*
* Only read the block if the length is not the block size.
*/
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
ffc25690: 81 39 00 1c lwz r9,28(r25)
ffc25694: 7e a4 ab 78 mr r4,r21
ffc25698: 80 a1 00 08 lwz r5,8(r1)
ffc2569c: 7e 66 9b 78 mr r6,r19
ffc256a0: 80 69 00 98 lwz r3,152(r9)
ffc256a4: 4b ff d1 b1 bl ffc22854 <rtems_rfs_buffer_handle_request>
rtems_rfs_file_buffer (handle),
block, read_block);
if (rc > 0)
ffc256a8: 7c 76 1b 79 mr. r22,r3
ffc256ac: 41 a1 ff 30 bgt- ffc255dc <rtems_rfs_file_set_size+0x88><== NEVER TAKEN
return rc;
dst = rtems_rfs_buffer_data (&handle->buffer);
ffc256b0: 81 39 00 0c lwz r9,12(r25)
memset (dst + bpos.boff, 0, length - bpos.boff);
ffc256b4: 38 80 00 00 li r4,0
ffc256b8: 80 01 00 10 lwz r0,16(r1)
ffc256bc: 80 69 00 24 lwz r3,36(r9)
ffc256c0: 7c a0 d0 50 subf r5,r0,r26
ffc256c4: 7c 63 02 14 add r3,r3,r0
ffc256c8: 48 00 54 ed bl ffc2abb4 <memset>
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
ffc256cc: 81 39 00 1c lwz r9,28(r25)
return rc;
dst = rtems_rfs_buffer_data (&handle->buffer);
memset (dst + bpos.boff, 0, length - bpos.boff);
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
ffc256d0: 9a 99 00 04 stb r20,4(r25)
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
ffc256d4: 7e a4 ab 78 mr r4,r21
ffc256d8: 80 69 00 98 lwz r3,152(r9)
ffc256dc: 4b ff cf 65 bl ffc22640 <rtems_rfs_buffer_handle_release>
rtems_rfs_file_buffer (handle));
if (rc > 0)
ffc256e0: 7c 76 1b 79 mr. r22,r3
ffc256e4: 41 a1 fe f8 bgt- ffc255dc <rtems_rfs_file_set_size+0x88><== NEVER TAKEN
return rc;
count -= length - bpos.boff;
ffc256e8: 80 01 00 10 lwz r0,16(r1)
ffc256ec: 3b 80 00 00 li r28,0
ffc256f0: 7f a0 d0 50 subf r29,r0,r26
ffc256f4: 7f fd f8 10 subfc r31,r29,r31
ffc256f8: 7f dc f1 10 subfe r30,r28,r30
count = new_size - size;
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
read_block = false;
while (count)
ffc256fc: 7f c9 fb 79 or. r9,r30,r31
ffc25700: 41 82 00 94 beq- ffc25794 <rtems_rfs_file_set_size+0x240><== ALWAYS TAKEN
ffc25704: 82 d9 00 1c lwz r22,28(r25) <== NOT EXECUTED
/*
* Get the block position for the current end of the file as seen by
* the map. If not found and the EOF grow the map then fill the block
* with 0.
*/
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos);
ffc25708: 80 18 00 40 lwz r0,64(r24)
ffc2570c: 81 38 00 3c lwz r9,60(r24)
ffc25710: 2f 80 00 00 cmpwi cr7,r0,0
ffc25714: 90 01 00 10 stw r0,16(r1)
ffc25718: 91 21 00 0c stw r9,12(r1)
ffc2571c: 93 61 00 14 stw r27,20(r1)
ffc25720: 41 9e 00 0c beq- cr7,ffc2572c <rtems_rfs_file_set_size+0x1d8>
ffc25724: 39 29 ff ff addi r9,r9,-1
ffc25728: 91 21 00 0c stw r9,12(r1)
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
ffc2572c: 80 76 00 98 lwz r3,152(r22)
ffc25730: 7e e4 bb 78 mr r4,r23
ffc25734: 38 a1 00 0c addi r5,r1,12
ffc25738: 38 c1 00 08 addi r6,r1,8
ffc2573c: 4b ff c2 39 bl ffc21974 <rtems_rfs_block_map_find>
map, &bpos, &block);
if (rc > 0)
ffc25740: 7c 76 1b 79 mr. r22,r3
ffc25744: 40 81 00 2c ble- ffc25770 <rtems_rfs_file_set_size+0x21c>
{
/*
* Have we reached the EOF ?
*/
if (rc != ENXIO)
ffc25748: 2f 96 00 06 cmpwi cr7,r22,6
ffc2574c: 40 be fe 90 bne- cr7,ffc255dc <rtems_rfs_file_set_size+0x88><== NEVER TAKEN
return rc;
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
ffc25750: 81 39 00 1c lwz r9,28(r25)
ffc25754: 7e e4 bb 78 mr r4,r23
ffc25758: 38 a0 00 01 li r5,1
ffc2575c: 80 69 00 98 lwz r3,152(r9)
ffc25760: 38 c1 00 08 addi r6,r1,8
ffc25764: 4b ff c4 bd bl ffc21c20 <rtems_rfs_block_map_grow>
map, 1, &block);
if (rc > 0)
ffc25768: 7c 76 1b 79 mr. r22,r3
ffc2576c: 41 a1 fe 70 bgt- ffc255dc <rtems_rfs_file_set_size+0x88><== NEVER TAKEN
return rc;
}
if (count < (length - bpos.boff))
ffc25770: 7f 9b f0 00 cmpw cr7,r27,r30
ffc25774: 80 01 00 10 lwz r0,16(r1)
ffc25778: 7d 20 d0 50 subf r9,r0,r26
ffc2577c: 41 be fe fc beq- cr7,ffc25678 <rtems_rfs_file_set_size+0x124><== ALWAYS TAKEN
ffc25780: 93 78 00 40 stw r27,64(r24) <== NOT EXECUTED
map->dirty = true;
ffc25784: 9a 98 00 34 stb r20,52(r24) <== NOT EXECUTED
ffc25788: 4b ff ff 08 b ffc25690 <rtems_rfs_file_set_size+0x13c><== NOT EXECUTED
size = rtems_rfs_file_size (handle);
/*
* If the file is same size do nothing else grow or shrink it ?
*/
if (size != new_size)
ffc2578c: 7f 1b 20 00 cmpw cr6,r27,r4
ffc25790: 40 9a fe ac bne+ cr6,ffc2563c <rtems_rfs_file_set_size+0xe8>
count = new_size - size;
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
read_block = false;
while (count)
ffc25794: 82 b9 00 1c lwz r21,28(r25)
ffc25798: 83 d8 00 3c lwz r30,60(r24)
ffc2579c: 80 98 00 40 lwz r4,64(r24)
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
if (rtems_rfs_file_update_mtime (handle))
ffc257a0: 80 19 00 00 lwz r0,0(r25)
handle->shared->mtime = time (NULL);
return 0;
ffc257a4: 3a c0 00 00 li r22,0
rtems_rfs_file_bpos (handle));
}
}
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
ffc257a8: 93 d5 00 84 stw r30,132(r21)
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
if (rtems_rfs_file_update_mtime (handle))
ffc257ac: 70 09 00 02 andi. r9,r0,2
}
}
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
ffc257b0: 90 95 00 88 stw r4,136(r21)
if (rtems_rfs_file_update_mtime (handle))
ffc257b4: 40 82 fe 28 bne+ ffc255dc <rtems_rfs_file_set_size+0x88><== NEVER TAKEN
handle->shared->mtime = time (NULL);
ffc257b8: 38 60 00 00 li r3,0
ffc257bc: 48 00 8e 09 bl ffc2e5c4 <time>
ffc257c0: 90 75 00 90 stw r3,144(r21)
ffc257c4: 4b ff fe 18 b ffc255dc <rtems_rfs_file_set_size+0x88>
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
rtems_rfs_pos size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-set-size: size=%" PRIu64 "\n", new_size);
ffc257c8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc257cc: 7f 45 d3 78 mr r5,r26 <== NOT EXECUTED
ffc257d0: 7f 66 db 78 mr r6,r27 <== NOT EXECUTED
ffc257d4: 38 63 d6 d4 addi r3,r3,-10540 <== NOT EXECUTED
ffc257d8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc257dc: 48 00 55 69 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc257e0: 4b ff fd dc b ffc255bc <rtems_rfs_file_set_size+0x68><== NOT EXECUTED
/*
* If the file is same size do nothing else grow or shrink it ?
*/
if (size != new_size)
{
if (size < new_size)
ffc257e4: 40 9e 00 0c bne- cr7,ffc257f0 <rtems_rfs_file_set_size+0x29c><== NEVER TAKEN
ffc257e8: 7f 9b 20 40 cmplw cr7,r27,r4
ffc257ec: 41 bd fe 58 bgt- cr7,ffc25644 <rtems_rfs_file_set_size+0xf0><== ALWAYS TAKEN
uint32_t offset;
blocks =
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
ffc257f0: 82 d9 00 1c lwz r22,28(r25) <== NOT EXECUTED
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
ffc257f4: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc257f8: 30 9b ff ff addic r4,r27,-1 <== NOT EXECUTED
ffc257fc: 7c 7a 01 d4 addme r3,r26 <== NOT EXECUTED
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
rtems_rfs_block_map_count (map) -
ffc25800: 83 d8 00 3c lwz r30,60(r24) <== NOT EXECUTED
(((new_size - 1) /
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
ffc25804: 82 f6 00 98 lwz r23,152(r22) <== NOT EXECUTED
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
ffc25808: 83 97 00 08 lwz r28,8(r23) <== NOT EXECUTED
ffc2580c: 7f 86 e3 78 mr r6,r28 <== NOT EXECUTED
ffc25810: 48 01 2a 8d bl ffc3829c <__udivdi3> <== NOT EXECUTED
* Shrink
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
ffc25814: 7c 85 20 f8 not r5,r4 <== NOT EXECUTED
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
offset =
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
if (blocks)
ffc25818: 7c a5 f2 15 add. r5,r5,r30 <== NOT EXECUTED
ffc2581c: 40 82 00 88 bne- ffc258a4 <rtems_rfs_file_set_size+0x350><== NOT EXECUTED
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
offset =
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
ffc25820: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc25824: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc25828: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc2582c: 7f 86 e3 78 mr r6,r28 <== NOT EXECUTED
ffc25830: 48 01 2e 61 bl ffc38690 <__umoddi3> <== NOT EXECUTED
ffc25834: 39 20 00 01 li r9,1 <== NOT EXECUTED
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
ffc25838: 90 98 00 40 stw r4,64(r24) <== NOT EXECUTED
return rc;
}
rtems_rfs_block_map_set_size_offset (map, offset);
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
ffc2583c: 80 19 00 10 lwz r0,16(r25) <== NOT EXECUTED
map->dirty = true;
ffc25840: 99 38 00 34 stb r9,52(r24) <== NOT EXECUTED
ffc25844: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc25848: 41 9e 00 34 beq- cr7,ffc2587c <rtems_rfs_file_set_size+0x328><== NOT EXECUTED
ffc2584c: 2f 9e 00 00 cmpwi cr7,r30,0 <== NOT EXECUTED
ffc25850: 40 9e 00 2c bne- cr7,ffc2587c <rtems_rfs_file_set_size+0x328><== NOT EXECUTED
rtems_rfs_block_map_size (map)))
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
ffc25854: 2f 84 00 00 cmpwi cr7,r4,0 <== NOT EXECUTED
ffc25858: 93 d9 00 10 stw r30,16(r25) <== NOT EXECUTED
ffc2585c: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc25860: 90 99 00 14 stw r4,20(r25) <== NOT EXECUTED
ffc25864: 90 19 00 18 stw r0,24(r25) <== NOT EXECUTED
ffc25868: 41 9e 00 0c beq- cr7,ffc25874 <rtems_rfs_file_set_size+0x320><== NOT EXECUTED
ffc2586c: 38 1e ff ff addi r0,r30,-1 <== NOT EXECUTED
ffc25870: 90 19 00 10 stw r0,16(r25) <== NOT EXECUTED
ffc25874: 7e d5 b3 78 mr r21,r22 <== NOT EXECUTED
ffc25878: 4b ff ff 28 b ffc257a0 <rtems_rfs_file_set_size+0x24c><== NOT EXECUTED
return rc;
}
rtems_rfs_block_map_set_size_offset (map, offset);
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
ffc2587c: 7f 80 f0 40 cmplw cr7,r0,r30 <== NOT EXECUTED
ffc25880: 40 bc ff d4 bge- cr7,ffc25854 <rtems_rfs_file_set_size+0x300><== NOT EXECUTED
ffc25884: 39 3e ff ff addi r9,r30,-1 <== NOT EXECUTED
ffc25888: 7f 80 48 00 cmpw cr7,r0,r9 <== NOT EXECUTED
ffc2588c: 40 9e ff e8 bne+ cr7,ffc25874 <rtems_rfs_file_set_size+0x320><== NOT EXECUTED
ffc25890: 80 19 00 14 lwz r0,20(r25) <== NOT EXECUTED
ffc25894: 7f 84 00 40 cmplw cr7,r4,r0 <== NOT EXECUTED
ffc25898: 41 bc ff bc blt- cr7,ffc25854 <rtems_rfs_file_set_size+0x300><== NOT EXECUTED
rtems_rfs_block_map_size (map)))
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
ffc2589c: 7e d5 b3 78 mr r21,r22 <== NOT EXECUTED
ffc258a0: 4b ff ff 00 b ffc257a0 <rtems_rfs_file_set_size+0x24c><== NOT EXECUTED
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
if (blocks)
{
int rc;
rc = rtems_rfs_block_map_shrink (rtems_rfs_file_fs (handle),
ffc258a4: 38 96 00 34 addi r4,r22,52 <== NOT EXECUTED
ffc258a8: 7e e3 bb 78 mr r3,r23 <== NOT EXECUTED
ffc258ac: 4b ff c7 9d bl ffc22048 <rtems_rfs_block_map_shrink> <== NOT EXECUTED
rtems_rfs_file_map (handle),
blocks);
if (rc > 0)
ffc258b0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc258b4: 7c 76 1b 78 mr r22,r3 <== NOT EXECUTED
ffc258b8: 41 9d fd 24 bgt+ cr7,ffc255dc <rtems_rfs_file_set_size+0x88><== NOT EXECUTED
ffc258bc: 83 d8 00 3c lwz r30,60(r24) <== NOT EXECUTED
ffc258c0: 82 d9 00 1c lwz r22,28(r25) <== NOT EXECUTED
ffc258c4: 4b ff ff 5c b ffc25820 <rtems_rfs_file_set_size+0x2cc><== NOT EXECUTED
ffc12580 <rtems_rfs_format>:
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
ffc12580: 94 21 fe d8 stwu r1,-296(r1)
ffc12584: 7c 08 02 a6 mflr r0
ffc12588: 7d 80 00 26 mfcr r12
ffc1258c: 90 01 01 2c stw r0,300(r1)
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
ffc12590: 88 04 00 15 lbz r0,21(r4)
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
ffc12594: 92 e1 01 04 stw r23,260(r1)
ffc12598: 7c 77 1b 78 mr r23,r3
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
ffc1259c: 2f 80 00 00 cmpwi cr7,r0,0
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
ffc125a0: 93 a1 01 1c stw r29,284(r1)
ffc125a4: 7c 9d 23 78 mr r29,r4
ffc125a8: 92 21 00 ec stw r17,236(r1)
ffc125ac: 92 41 00 f0 stw r18,240(r1)
ffc125b0: 92 61 00 f4 stw r19,244(r1)
ffc125b4: 92 81 00 f8 stw r20,248(r1)
ffc125b8: 92 a1 00 fc stw r21,252(r1)
ffc125bc: 92 c1 01 00 stw r22,256(r1)
ffc125c0: 93 01 01 08 stw r24,264(r1)
ffc125c4: 93 21 01 0c stw r25,268(r1)
ffc125c8: 93 41 01 10 stw r26,272(r1)
ffc125cc: 93 61 01 14 stw r27,276(r1)
ffc125d0: 93 81 01 18 stw r28,280(r1)
ffc125d4: 93 c1 01 20 stw r30,288(r1)
ffc125d8: 93 e1 01 24 stw r31,292(r1)
ffc125dc: 91 81 00 e8 stw r12,232(r1)
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
ffc125e0: 40 9e 02 5c bne- cr7,ffc1283c <rtems_rfs_format+0x2bc> <== NEVER TAKEN
printf ("rtems-rfs: format: %s\n", name);
memset (&fs, 0, sizeof (rtems_rfs_file_system));
ffc125e4: 38 80 00 00 li r4,0
ffc125e8: 38 a0 00 80 li r5,128
ffc125ec: 38 61 00 5c addi r3,r1,92
ffc125f0: 48 01 85 c5 bl ffc2abb4 <memset>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc125f4: 7c 28 0b 78 mr r8,r1
ffc125f8: 38 01 00 a0 addi r0,r1,160
ffc125fc: 7c 2a 0b 78 mr r10,r1
ffc12600: 94 08 00 9c stwu r0,156(r8)
ffc12604: 38 01 00 b0 addi r0,r1,176
ffc12608: 7c 2b 0b 78 mr r11,r1
ffc1260c: 94 0a 00 ac stwu r0,172(r10)
ffc12610: 38 01 00 c0 addi r0,r1,192
ffc12614: 7c 29 0b 78 mr r9,r1
ffc12618: 94 0b 00 bc stwu r0,188(r11)
ffc1261c: 38 01 00 d0 addi r0,r1,208
ffc12620: 94 09 00 cc stwu r0,204(r9)
rtems_chain_initialize_empty (&fs.buffers);
rtems_chain_initialize_empty (&fs.release);
rtems_chain_initialize_empty (&fs.release_modified);
rtems_chain_initialize_empty (&fs.file_shares);
fs.max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
ffc12624: 38 00 00 05 li r0,5
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
ffc12628: 7e e3 bb 78 mr r3,r23
rtems_chain_initialize_empty (&fs.buffers);
rtems_chain_initialize_empty (&fs.release);
rtems_chain_initialize_empty (&fs.release_modified);
rtems_chain_initialize_empty (&fs.file_shares);
fs.max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
ffc1262c: 90 01 00 98 stw r0,152(r1)
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
ffc12630: 38 81 00 5c addi r4,r1,92
fs.max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
fs.release_count = 0;
fs.release_modified_count = 0;
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
ffc12634: 38 00 00 02 li r0,2
head->previous = NULL;
tail->previous = head;
ffc12638: 91 01 00 a4 stw r8,164(r1)
ffc1263c: 91 41 00 b4 stw r10,180(r1)
ffc12640: 91 61 00 c4 stw r11,196(r1)
ffc12644: 91 21 00 d4 stw r9,212(r1)
ffc12648: 90 01 00 5c stw r0,92(r1)
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
ffc1264c: 48 01 05 19 bl ffc22b64 <rtems_rfs_buffer_open>
if (rc > 0)
ffc12650: 7c 7f 1b 79 mr. r31,r3
ffc12654: 41 81 0d 78 bgt- ffc133cc <rtems_rfs_format+0xe4c> <== NEVER TAKEN
}
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
ffc12658: 81 21 00 68 lwz r9,104(r1)
ffc1265c: 80 a9 00 24 lwz r5,36(r9)
ffc12660: 2f 85 00 00 cmpwi cr7,r5,0
ffc12664: 41 9e 0d b0 beq- cr7,ffc13414 <rtems_rfs_format+0xe94> <== NEVER TAKEN
static bool
rtems_rfs_check_config (rtems_rfs_file_system* fs,
const rtems_rfs_format_config* config)
{
fs->block_size = config->block_size;
ffc12668: 80 9d 00 00 lwz r4,0(r29)
if (!fs->block_size)
ffc1266c: 2f 84 00 00 cmpwi cr7,r4,0
static bool
rtems_rfs_check_config (rtems_rfs_file_system* fs,
const rtems_rfs_format_config* config)
{
fs->block_size = config->block_size;
ffc12670: 90 81 00 64 stw r4,100(r1)
if (!fs->block_size)
ffc12674: 41 9e 03 88 beq- cr7,ffc129fc <rtems_rfs_format+0x47c> <== NEVER TAKEN
if (fs->block_size > (4 * 1024))
fs->block_size = (4 * 1024);
}
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
ffc12678: 7c 04 2b 96 divwu r0,r4,r5
ffc1267c: 7c 00 29 d6 mullw r0,r0,r5
ffc12680: 7f 84 00 00 cmpw cr7,r4,r0
ffc12684: 40 9e 03 c8 bne- cr7,ffc12a4c <rtems_rfs_format+0x4cc> <== NEVER TAKEN
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
fs->block_size, rtems_rfs_fs_media_block_size (fs));
return false;
}
fs->group_blocks = config->group_blocks;
ffc12688: 80 1d 00 04 lwz r0,4(r29)
{
/*
* The number of blocks per group is defined by the number of bits in a
* block.
*/
fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);
ffc1268c: 54 84 18 38 rlwinm r4,r4,3,0,28
fs->block_size, rtems_rfs_fs_media_block_size (fs));
return false;
}
fs->group_blocks = config->group_blocks;
if (!fs->group_blocks)
ffc12690: 2f 80 00 00 cmpwi cr7,r0,0
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
fs->block_size, rtems_rfs_fs_media_block_size (fs));
return false;
}
fs->group_blocks = config->group_blocks;
ffc12694: 90 01 00 80 stw r0,128(r1)
if (!fs->group_blocks)
ffc12698: 40 9e 01 38 bne- cr7,ffc127d0 <rtems_rfs_format+0x250> <== NEVER TAKEN
{
/*
* The number of blocks per group is defined by the number of bits in a
* block.
*/
fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);
ffc1269c: 90 81 00 80 stw r4,128(r1)
{
printf ("group block count is higher than bits in block\n");
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
ffc126a0: 38 61 00 5c addi r3,r1,92
ffc126a4: 48 01 32 89 bl ffc2592c <rtems_rfs_fs_media_size>
ffc126a8: 83 e1 00 64 lwz r31,100(r1)
ffc126ac: 38 a0 00 00 li r5,0
ffc126b0: 7f e6 fb 78 mr r6,r31
ffc126b4: 48 02 5b e9 bl ffc3829c <__udivdi3>
* Return the number of bits that fit in the block size.
*/
static int
rtems_rfs_bits_per_block (rtems_rfs_file_system* fs)
{
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
ffc126b8: 57 e9 18 38 rlwinm r9,r31,3,0,28
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
ffc126bc: 2f 84 00 00 cmpwi cr7,r4,0
{
printf ("group block count is higher than bits in block\n");
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
ffc126c0: 90 81 00 60 stw r4,96(r1)
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
return 1;
ffc126c4: 38 00 00 01 li r0,1
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
ffc126c8: 41 9e 00 10 beq- cr7,ffc126d8 <rtems_rfs_format+0x158> <== NEVER TAKEN
return 1;
return ((dividend - 1) / divisor) + 1;
ffc126cc: 39 64 ff ff addi r11,r4,-1
ffc126d0: 7d 6b 4b 96 divwu r11,r11,r9
ffc126d4: 38 0b 00 01 addi r0,r11,1
* per block.
*/
fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
ffc126d8: 81 7d 00 08 lwz r11,8(r29)
/*
* The bits per block sets the upper limit for the number of blocks in a
* group. The disk will be divided into groups which are the number of bits
* per block.
*/
fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
ffc126dc: 90 01 00 7c stw r0,124(r1)
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
if (!fs->group_inodes)
ffc126e0: 2f 8b 00 00 cmpwi cr7,r11,0
ffc126e4: 41 9e 05 38 beq- cr7,ffc12c1c <rtems_rfs_format+0x69c> <== ALWAYS TAKEN
ffc126e8: 3c 00 24 92 lis r0,9362 <== NOT EXECUTED
ffc126ec: 57 ea e8 fe rlwinm r10,r31,29,3,31 <== NOT EXECUTED
ffc126f0: 60 00 49 25 ori r0,r0,18725 <== NOT EXECUTED
ffc126f4: 7c 0a 00 16 mulhwu r0,r10,r0 <== NOT EXECUTED
}
/*
* Round up to fill a block because the minimum allocation unit is a block.
*/
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
ffc126f8: 90 01 00 88 stw r0,136(r1) <== NOT EXECUTED
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
return 1;
return ((dividend - 1) / divisor) + 1;
ffc126fc: 39 4b ff ff addi r10,r11,-1
ffc12700: 7d 4a 03 96 divwu r10,r10,r0
ffc12704: 39 4a 00 01 addi r10,r10,1
* Round up to fill a block because the minimum allocation unit is a block.
*/
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
fs->group_inodes =
rtems_rfs_rup_quotient (fs->group_inodes,
fs->inodes_per_block) * fs->inodes_per_block;
ffc12708: 7c 0a 01 d6 mullw r0,r10,r0
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
ffc1270c: 7f 89 00 40 cmplw cr7,r9,r0
/*
* Round up to fill a block because the minimum allocation unit is a block.
*/
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
fs->group_inodes =
ffc12710: 90 01 00 84 stw r0,132(r1)
rtems_rfs_rup_quotient (fs->group_inodes,
fs->inodes_per_block) * fs->inodes_per_block;
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
ffc12714: 40 9c 00 08 bge- cr7,ffc1271c <rtems_rfs_format+0x19c> <== ALWAYS TAKEN
fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);
ffc12718: 91 21 00 84 stw r9,132(r1) <== NOT EXECUTED
fs->max_name_length = config->max_name_length;
ffc1271c: 80 1d 00 10 lwz r0,16(r29)
if (!fs->max_name_length)
ffc12720: 2f 80 00 00 cmpwi cr7,r0,0
fs->inodes_per_block) * fs->inodes_per_block;
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);
fs->max_name_length = config->max_name_length;
ffc12724: 90 01 00 74 stw r0,116(r1)
if (!fs->max_name_length)
ffc12728: 40 9e 00 0c bne- cr7,ffc12734 <rtems_rfs_format+0x1b4> <== NEVER TAKEN
{
fs->max_name_length = 512;
ffc1272c: 38 00 02 00 li r0,512
ffc12730: 90 01 00 74 stw r0,116(r1)
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
if (config->verbose)
ffc12734: 88 1d 00 15 lbz r0,21(r29)
ffc12738: 2f 80 00 00 cmpwi cr7,r0,0
ffc1273c: 40 9e 03 28 bne- cr7,ffc12a64 <rtems_rfs_format+0x4e4> <== NEVER TAKEN
printf ("rtems-rfs: format: groups = %u\n", fs.group_count);
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
}
rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
ffc12740: 7f e4 fb 78 mr r4,r31
ffc12744: 38 61 00 5c addi r3,r1,92
ffc12748: 48 01 07 49 bl ffc22e90 <rtems_rfs_buffer_setblksize>
if (rc > 0)
ffc1274c: 7c 7f 1b 79 mr. r31,r3
ffc12750: 41 81 0a 28 bgt- ffc13178 <rtems_rfs_format+0xbf8> <== NEVER TAKEN
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
handle->bnum = 0;
ffc12754: 3b e0 00 00 li r31,0
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc12758: 38 00 00 00 li r0,0
handle->bnum = 0;
ffc1275c: 93 e1 00 14 stw r31,20(r1)
printf ("rtems-rfs: write-superblock: handle open failed: %d: %s\n",
rc, strerror (rc));
return false;
}
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, false);
ffc12760: 38 61 00 5c addi r3,r1,92
ffc12764: 38 81 00 10 addi r4,r1,16
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc12768: 98 01 00 10 stb r0,16(r1)
ffc1276c: 38 a0 00 00 li r5,0
ffc12770: 38 c0 00 00 li r6,0
handle->bnum = 0;
handle->buffer = NULL;
ffc12774: 93 e1 00 18 stw r31,24(r1)
ffc12778: 48 01 00 dd bl ffc22854 <rtems_rfs_buffer_handle_request>
if (rc > 0)
ffc1277c: 7c 7e 1b 79 mr. r30,r3
ffc12780: 40 81 00 d4 ble- ffc12854 <rtems_rfs_format+0x2d4> <== ALWAYS TAKEN
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc12784: 38 81 00 10 addi r4,r1,16 <== NOT EXECUTED
ffc12788: 38 61 00 5c addi r3,r1,92 <== NOT EXECUTED
ffc1278c: 48 00 fe b5 bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
ffc12790: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
handle->dirty = false;
ffc12794: 9b e1 00 10 stb r31,16(r1) <== NOT EXECUTED
handle->bnum = 0;
ffc12798: 93 e1 00 14 stw r31,20(r1) <== NOT EXECUTED
handle->buffer = NULL;
ffc1279c: 93 e1 00 18 stw r31,24(r1) <== NOT EXECUTED
ffc127a0: 48 01 93 11 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc127a4: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc127a8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc127ac: 38 63 b2 24 addi r3,r3,-19932 <== NOT EXECUTED
ffc127b0: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc127b4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc127b8: 48 01 85 8d bl ffc2ad44 <printf> <== NOT EXECUTED
return -1;
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
ffc127bc: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc127c0: 38 63 b2 98 addi r3,r3,-19816 <== NOT EXECUTED
ffc127c4: 48 01 87 35 bl ffc2aef8 <puts> <== NOT EXECUTED
return -1;
ffc127c8: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc127cc: 48 00 00 1c b ffc127e8 <rtems_rfs_format+0x268> <== NOT EXECUTED
* block.
*/
fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);
}
if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
ffc127d0: 7f 80 20 40 cmplw cr7,r0,r4 <== NOT EXECUTED
ffc127d4: 40 bd fe cc ble- cr7,ffc126a0 <rtems_rfs_format+0x120> <== NOT EXECUTED
{
printf ("group block count is higher than bits in block\n");
ffc127d8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc127dc: 38 63 af e8 addi r3,r3,-20504 <== NOT EXECUTED
ffc127e0: 48 01 87 19 bl ffc2aef8 <puts> <== NOT EXECUTED
/*
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
ffc127e4: 38 60 ff ff li r3,-1 <== NOT EXECUTED
rc, strerror (rc));
return -1;
}
return 0;
}
ffc127e8: 80 01 01 2c lwz r0,300(r1)
ffc127ec: 81 81 00 e8 lwz r12,232(r1)
ffc127f0: 7c 08 03 a6 mtlr r0
ffc127f4: 82 21 00 ec lwz r17,236(r1)
ffc127f8: 82 41 00 f0 lwz r18,240(r1)
ffc127fc: 7d 80 81 20 mtcrf 8,r12
ffc12800: 82 61 00 f4 lwz r19,244(r1)
ffc12804: 82 81 00 f8 lwz r20,248(r1)
ffc12808: 82 a1 00 fc lwz r21,252(r1)
ffc1280c: 82 c1 01 00 lwz r22,256(r1)
ffc12810: 82 e1 01 04 lwz r23,260(r1)
ffc12814: 83 01 01 08 lwz r24,264(r1)
ffc12818: 83 21 01 0c lwz r25,268(r1)
ffc1281c: 83 41 01 10 lwz r26,272(r1)
ffc12820: 83 61 01 14 lwz r27,276(r1)
ffc12824: 83 81 01 18 lwz r28,280(r1)
ffc12828: 83 a1 01 1c lwz r29,284(r1)
ffc1282c: 83 c1 01 20 lwz r30,288(r1)
ffc12830: 83 e1 01 24 lwz r31,292(r1)
ffc12834: 38 21 01 28 addi r1,r1,296
ffc12838: 4e 80 00 20 blr
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
printf ("rtems-rfs: format: %s\n", name);
ffc1283c: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc12840: 7e e4 bb 78 mr r4,r23 <== NOT EXECUTED
ffc12844: 38 63 af 38 addi r3,r3,-20680 <== NOT EXECUTED
ffc12848: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1284c: 48 01 84 f9 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc12850: 4b ff fd 94 b ffc125e4 <rtems_rfs_format+0x64> <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
rc, strerror (rc));
return false;
}
sb = rtems_rfs_buffer_data (&handle);
ffc12854: 81 21 00 18 lwz r9,24(r1)
#define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
ffc12858: 38 80 00 ff li r4,255
ffc1285c: 80 a1 00 64 lwz r5,100(r1)
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
rc, strerror (rc));
return false;
}
sb = rtems_rfs_buffer_data (&handle);
ffc12860: 83 c9 00 24 lwz r30,36(r9)
#define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
ffc12864: 7f c3 f3 78 mr r3,r30
ffc12868: 48 01 83 4d bl ffc2abb4 <memset>
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
ffc1286c: 38 00 00 28 li r0,40
ffc12870: 98 1e 00 00 stb r0,0(r30)
ffc12874: 38 00 00 09 li r0,9
ffc12878: 39 20 00 01 li r9,1
ffc1287c: 98 1e 00 01 stb r0,1(r30)
ffc12880: 38 00 00 20 li r0,32
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
rtems_rfs_buffer_mark_dirty (&handle);
rc = rtems_rfs_buffer_handle_release (fs, &handle);
ffc12884: 38 61 00 5c addi r3,r1,92
#define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
ffc12888: 99 3e 00 03 stb r9,3(r30)
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
rtems_rfs_buffer_mark_dirty (&handle);
rc = rtems_rfs_buffer_handle_release (fs, &handle);
ffc1288c: 38 81 00 10 addi r4,r1,16
#define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
ffc12890: 98 1e 00 02 stb r0,2(r30)
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
ffc12894: 9b fe 00 04 stb r31,4(r30)
ffc12898: 9b fe 00 05 stb r31,5(r30)
ffc1289c: 9b fe 00 06 stb r31,6(r30)
ffc128a0: 9b fe 00 07 stb r31,7(r30)
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
ffc128a4: 89 61 00 64 lbz r11,100(r1)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
ffc128a8: 80 01 00 60 lwz r0,96(r1)
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
ffc128ac: 99 7e 00 08 stb r11,8(r30)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
ffc128b0: 54 08 46 3e rlwinm r8,r0,8,24,31
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
ffc128b4: a1 61 00 64 lhz r11,100(r1)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
ffc128b8: 54 0a 84 3e rlwinm r10,r0,16,16,31
ffc128bc: 99 1e 00 0c stb r8,12(r30)
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
ffc128c0: 99 7e 00 09 stb r11,9(r30)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
ffc128c4: 54 0b c2 3e rlwinm r11,r0,24,8,31
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
ffc128c8: 81 01 00 64 lwz r8,100(r1)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
ffc128cc: 98 1e 00 0f stb r0,15(r30)
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
ffc128d0: 55 08 c2 3e rlwinm r8,r8,24,8,31
ffc128d4: 99 1e 00 0a stb r8,10(r30)
ffc128d8: 80 01 00 64 lwz r0,100(r1)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
ffc128dc: 99 5e 00 0d stb r10,13(r30)
ffc128e0: 99 7e 00 0e stb r11,14(r30)
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
ffc128e4: 98 1e 00 0b stb r0,11(r30)
write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);
ffc128e8: 88 01 00 70 lbz r0,112(r1)
ffc128ec: 98 1e 00 10 stb r0,16(r30)
ffc128f0: a0 01 00 70 lhz r0,112(r1)
ffc128f4: 98 1e 00 11 stb r0,17(r30)
ffc128f8: 80 01 00 70 lwz r0,112(r1)
ffc128fc: 54 00 c2 3e rlwinm r0,r0,24,8,31
ffc12900: 98 1e 00 12 stb r0,18(r30)
ffc12904: 80 01 00 70 lwz r0,112(r1)
ffc12908: 98 1e 00 13 stb r0,19(r30)
write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
ffc1290c: 88 01 00 74 lbz r0,116(r1)
ffc12910: 98 1e 00 14 stb r0,20(r30)
ffc12914: a0 01 00 74 lhz r0,116(r1)
ffc12918: 98 1e 00 15 stb r0,21(r30)
ffc1291c: 80 01 00 74 lwz r0,116(r1)
ffc12920: 54 00 c2 3e rlwinm r0,r0,24,8,31
ffc12924: 98 1e 00 16 stb r0,22(r30)
ffc12928: 80 01 00 74 lwz r0,116(r1)
ffc1292c: 98 1e 00 17 stb r0,23(r30)
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
ffc12930: 88 01 00 7c lbz r0,124(r1)
ffc12934: 98 1e 00 18 stb r0,24(r30)
ffc12938: a0 01 00 7c lhz r0,124(r1)
ffc1293c: 98 1e 00 19 stb r0,25(r30)
ffc12940: 80 01 00 7c lwz r0,124(r1)
ffc12944: 54 00 c2 3e rlwinm r0,r0,24,8,31
ffc12948: 98 1e 00 1a stb r0,26(r30)
ffc1294c: 80 01 00 7c lwz r0,124(r1)
ffc12950: 98 1e 00 1b stb r0,27(r30)
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
ffc12954: 88 01 00 80 lbz r0,128(r1)
ffc12958: 98 1e 00 1c stb r0,28(r30)
ffc1295c: a0 01 00 80 lhz r0,128(r1)
ffc12960: 98 1e 00 1d stb r0,29(r30)
ffc12964: 80 01 00 80 lwz r0,128(r1)
ffc12968: 54 00 c2 3e rlwinm r0,r0,24,8,31
ffc1296c: 98 1e 00 1e stb r0,30(r30)
ffc12970: 80 01 00 80 lwz r0,128(r1)
ffc12974: 98 1e 00 1f stb r0,31(r30)
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
ffc12978: 88 01 00 84 lbz r0,132(r1)
ffc1297c: 98 1e 00 20 stb r0,32(r30)
ffc12980: a0 01 00 84 lhz r0,132(r1)
ffc12984: 98 1e 00 21 stb r0,33(r30)
ffc12988: 80 01 00 84 lwz r0,132(r1)
ffc1298c: 54 00 c2 3e rlwinm r0,r0,24,8,31
ffc12990: 98 1e 00 22 stb r0,34(r30)
ffc12994: 80 01 00 84 lwz r0,132(r1)
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
ffc12998: 9b fe 00 24 stb r31,36(r30)
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);
write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
ffc1299c: 98 1e 00 23 stb r0,35(r30)
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
ffc129a0: 38 00 00 38 li r0,56
ffc129a4: 9b fe 00 25 stb r31,37(r30)
ffc129a8: 9b fe 00 26 stb r31,38(r30)
ffc129ac: 98 1e 00 27 stb r0,39(r30)
rtems_rfs_buffer_mark_dirty (&handle);
ffc129b0: 99 21 00 10 stb r9,16(r1)
rc = rtems_rfs_buffer_handle_release (fs, &handle);
ffc129b4: 48 00 fc 8d bl ffc22640 <rtems_rfs_buffer_handle_release>
if (rc > 0)
ffc129b8: 7c 7e 1b 79 mr. r30,r3
ffc129bc: 40 81 03 8c ble- ffc12d48 <rtems_rfs_format+0x7c8> <== ALWAYS TAKEN
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc129c0: 38 81 00 10 addi r4,r1,16 <== NOT EXECUTED
ffc129c4: 38 61 00 5c addi r3,r1,92 <== NOT EXECUTED
ffc129c8: 48 00 fc 79 bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("rtems-rfs: write-superblock: buffer release failed: %d: %s\n",
ffc129cc: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
handle->dirty = false;
ffc129d0: 9b e1 00 10 stb r31,16(r1) <== NOT EXECUTED
handle->bnum = 0;
ffc129d4: 93 e1 00 14 stw r31,20(r1) <== NOT EXECUTED
handle->buffer = NULL;
ffc129d8: 93 e1 00 18 stw r31,24(r1) <== NOT EXECUTED
ffc129dc: 48 01 90 d5 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc129e0: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc129e4: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc129e8: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc129ec: 38 63 b2 5c addi r3,r3,-19876 <== NOT EXECUTED
ffc129f0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc129f4: 48 01 83 51 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc129f8: 4b ff fd c4 b ffc127bc <rtems_rfs_format+0x23c> <== NOT EXECUTED
const rtems_rfs_format_config* config)
{
fs->block_size = config->block_size;
if (!fs->block_size)
{
uint64_t total_size = rtems_rfs_fs_media_size (fs);
ffc129fc: 38 61 00 5c addi r3,r1,92 <== NOT EXECUTED
ffc12a00: 48 01 2f 2d bl ffc2592c <rtems_rfs_fs_media_size> <== NOT EXECUTED
if (total_size >= GIGS (1))
ffc12a04: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc12a08: 40 82 02 6c bne- ffc12c74 <rtems_rfs_format+0x6f4> <== NOT EXECUTED
ffc12a0c: 3c 00 00 0f lis r0,15 <== NOT EXECUTED
ffc12a10: 60 00 ff ff ori r0,r0,65535 <== NOT EXECUTED
ffc12a14: 7f 84 00 40 cmplw cr7,r4,r0 <== NOT EXECUTED
ffc12a18: 41 9d 02 5c bgt- cr7,ffc12c74 <rtems_rfs_format+0x6f4> <== NOT EXECUTED
ffc12a1c: 80 81 00 64 lwz r4,100(r1) <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
break;
fs->block_size = 1 << b;
}
if (fs->block_size < 512)
ffc12a20: 2b 84 01 ff cmplwi cr7,r4,511 <== NOT EXECUTED
ffc12a24: 41 9d 02 9c bgt- cr7,ffc12cc0 <rtems_rfs_format+0x740> <== NOT EXECUTED
fs->block_size = 512;
ffc12a28: 81 21 00 68 lwz r9,104(r1) <== NOT EXECUTED
ffc12a2c: 38 00 02 00 li r0,512 <== NOT EXECUTED
ffc12a30: 38 80 02 00 li r4,512 <== NOT EXECUTED
ffc12a34: 90 01 00 64 stw r0,100(r1) <== NOT EXECUTED
ffc12a38: 80 a9 00 24 lwz r5,36(r9) <== NOT EXECUTED
if (fs->block_size > (4 * 1024))
fs->block_size = (4 * 1024);
}
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
ffc12a3c: 7c 04 2b 96 divwu r0,r4,r5 <== NOT EXECUTED
ffc12a40: 7c 00 29 d6 mullw r0,r0,r5 <== NOT EXECUTED
ffc12a44: 7f 84 00 00 cmpw cr7,r4,r0 <== NOT EXECUTED
ffc12a48: 41 9e fc 40 beq+ cr7,ffc12688 <rtems_rfs_format+0x108> <== NOT EXECUTED
{
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
ffc12a4c: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc12a50: 38 63 af a8 addi r3,r3,-20568 <== NOT EXECUTED
ffc12a54: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc12a58: 48 01 82 ed bl ffc2ad44 <printf> <== NOT EXECUTED
/*
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
ffc12a5c: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc12a60: 4b ff fd 88 b ffc127e8 <rtems_rfs_format+0x268> <== NOT EXECUTED
if (config->verbose)
{
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
ffc12a64: 38 61 00 5c addi r3,r1,92 <== NOT EXECUTED
ffc12a68: 48 01 2e c5 bl ffc2592c <rtems_rfs_fs_media_size> <== NOT EXECUTED
ffc12a6c: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc12a70: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc12a74: 7c 86 23 78 mr r6,r4 <== NOT EXECUTED
ffc12a78: 38 63 b0 18 addi r3,r3,-20456 <== NOT EXECUTED
ffc12a7c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc12a80: 48 01 82 c5 bl ffc2ad44 <printf> <== NOT EXECUTED
rtems_rfs_fs_media_size (&fs));
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
rtems_rfs_fs_media_blocks (&fs));
ffc12a84: 81 21 00 68 lwz r9,104(r1) <== NOT EXECUTED
if (config->verbose)
{
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
rtems_rfs_fs_media_size (&fs));
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
ffc12a88: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc12a8c: 80 89 00 1c lwz r4,28(r9) <== NOT EXECUTED
ffc12a90: 38 63 b0 40 addi r3,r3,-20416 <== NOT EXECUTED
ffc12a94: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc12a98: 48 01 82 ad bl ffc2ad44 <printf> <== NOT EXECUTED
rtems_rfs_fs_media_blocks (&fs));
printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",
rtems_rfs_fs_media_block_size (&fs));
ffc12a9c: 81 21 00 68 lwz r9,104(r1) <== NOT EXECUTED
{
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
rtems_rfs_fs_media_size (&fs));
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
rtems_rfs_fs_media_blocks (&fs));
printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",
ffc12aa0: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc12aa4: 80 89 00 24 lwz r4,36(r9) <== NOT EXECUTED
ffc12aa8: 38 63 b0 68 addi r3,r3,-20376 <== NOT EXECUTED
ffc12aac: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc12ab0: 48 01 82 95 bl ffc2ad44 <printf> <== NOT EXECUTED
rtems_rfs_fs_media_block_size (&fs));
printf ("rtems-rfs: format: size = %" PRIu64 "\n",
ffc12ab4: 38 61 00 5c addi r3,r1,92 <== NOT EXECUTED
ffc12ab8: 48 01 2e 61 bl ffc25918 <rtems_rfs_fs_size> <== NOT EXECUTED
ffc12abc: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc12ac0: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc12ac4: 7c 86 23 78 mr r6,r4 <== NOT EXECUTED
ffc12ac8: 38 63 b0 94 addi r3,r3,-20332 <== NOT EXECUTED
ffc12acc: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc12ad0: 48 01 82 75 bl ffc2ad44 <printf> <== NOT EXECUTED
rtems_rfs_fs_size (&fs));
printf ("rtems-rfs: format: blocks = %zu\n",
ffc12ad4: 80 81 00 60 lwz r4,96(r1) <== NOT EXECUTED
ffc12ad8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc12adc: 38 63 b0 b4 addi r3,r3,-20300 <== NOT EXECUTED
ffc12ae0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc12ae4: 48 01 82 61 bl ffc2ad44 <printf> <== NOT EXECUTED
rtems_rfs_fs_blocks (&fs));
printf ("rtems-rfs: format: block size = %zu\n",
ffc12ae8: 80 81 00 64 lwz r4,100(r1) <== NOT EXECUTED
ffc12aec: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc12af0: 38 63 b0 d8 addi r3,r3,-20264 <== NOT EXECUTED
ffc12af4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc12af8: 48 01 82 4d bl ffc2ad44 <printf> <== NOT EXECUTED
* Return the number of bits that fit in the block size.
*/
static int
rtems_rfs_bits_per_block (rtems_rfs_file_system* fs)
{
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
ffc12afc: 80 81 00 64 lwz r4,100(r1) <== NOT EXECUTED
rtems_rfs_fs_size (&fs));
printf ("rtems-rfs: format: blocks = %zu\n",
rtems_rfs_fs_blocks (&fs));
printf ("rtems-rfs: format: block size = %zu\n",
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
ffc12b00: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc12b04: 54 84 18 38 rlwinm r4,r4,3,0,28 <== NOT EXECUTED
ffc12b08: 38 63 b1 00 addi r3,r3,-20224 <== NOT EXECUTED
ffc12b0c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc12b10: 48 01 82 35 bl ffc2ad44 <printf> <== NOT EXECUTED
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
ffc12b14: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc12b18: 38 80 00 38 li r4,56 <== NOT EXECUTED
ffc12b1c: 38 63 b1 28 addi r3,r3,-20184 <== NOT EXECUTED
ffc12b20: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc12b24: 48 01 82 21 bl ffc2ad44 <printf> <== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
fs.group_inodes * fs.group_count,
ffc12b28: 80 01 00 84 lwz r0,132(r1) <== NOT EXECUTED
printf ("rtems-rfs: format: block size = %zu\n",
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
ffc12b2c: 80 81 00 7c lwz r4,124(r1) <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
ffc12b30: 38 c0 07 d0 li r6,2000 <== NOT EXECUTED
static int
rtems_rfs_inode_overhead (rtems_rfs_file_system* fs)
{
int blocks;
int bits_per_block;
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
ffc12b34: 1c e0 00 38 mulli r7,r0,56 <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
ffc12b38: 81 01 00 64 lwz r8,100(r1) <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
ffc12b3c: 2f 87 00 00 cmpwi cr7,r7,0 <== NOT EXECUTED
printf ("rtems-rfs: format: block size = %zu\n",
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
ffc12b40: 7c 80 21 d6 mullw r4,r0,r4 <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
ffc12b44: 40 9e 01 9c bne- cr7,ffc12ce0 <rtems_rfs_format+0x760> <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
bits_per_block = rtems_rfs_bits_per_block (fs);
/*
* There could be more bits than blocks, eg 512K disk with 512 blocks.
*/
if (bits_per_block > (rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE))
ffc12b48: 81 61 00 60 lwz r11,96(r1) <== NOT EXECUTED
* Return the number of bits that fit in the block size.
*/
static int
rtems_rfs_bits_per_block (rtems_rfs_file_system* fs)
{
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
ffc12b4c: 55 09 18 38 rlwinm r9,r8,3,0,28 <== NOT EXECUTED
ffc12b50: 7d 20 4b 78 mr r0,r9 <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
bits_per_block = rtems_rfs_bits_per_block (fs);
/*
* There could be more bits than blocks, eg 512K disk with 512 blocks.
*/
if (bits_per_block > (rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE))
ffc12b54: 39 6b ff ff addi r11,r11,-1 <== NOT EXECUTED
ffc12b58: 7f 09 58 40 cmplw cr6,r9,r11 <== NOT EXECUTED
{
int blocks;
int bits_per_block;
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
rtems_rfs_fs_block_size (fs));
bits_per_block = rtems_rfs_bits_per_block (fs);
ffc12b5c: 7d 2a 4b 78 mr r10,r9 <== NOT EXECUTED
/*
* There could be more bits than blocks, eg 512K disk with 512 blocks.
*/
if (bits_per_block > (rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE))
ffc12b60: 40 99 00 08 ble- cr6,ffc12b68 <rtems_rfs_format+0x5e8> <== NOT EXECUTED
bits_per_block = rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE;
ffc12b64: 7d 6a 5b 78 mr r10,r11 <== NOT EXECUTED
return ((blocks + 1) * 100 * 10) / bits_per_block;
ffc12b68: 7d 46 53 d6 divw r10,r6,r10 <== NOT EXECUTED
printf ("rtems-rfs: format: block size = %zu\n",
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
ffc12b6c: 3c a0 66 66 lis r5,26214 <== NOT EXECUTED
ffc12b70: 60 a5 66 67 ori r5,r5,26215 <== NOT EXECUTED
ffc12b74: 7c aa 28 96 mulhw r5,r10,r5 <== NOT EXECUTED
ffc12b78: 7d 4a fe 70 srawi r10,r10,31 <== NOT EXECUTED
ffc12b7c: 7c a5 16 70 srawi r5,r5,2 <== NOT EXECUTED
ffc12b80: 7c aa 28 50 subf r5,r10,r5 <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
ffc12b84: 41 9e 01 8c beq- cr7,ffc12d10 <rtems_rfs_format+0x790> <== NOT EXECUTED
return 1;
return ((dividend - 1) / divisor) + 1;
ffc12b88: 39 47 ff ff addi r10,r7,-1 <== NOT EXECUTED
ffc12b8c: 7d 4a 43 96 divwu r10,r10,r8 <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
ffc12b90: 39 4a 00 02 addi r10,r10,2 <== NOT EXECUTED
ffc12b94: 1d 4a 03 e8 mulli r10,r10,1000 <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
bits_per_block = rtems_rfs_bits_per_block (fs);
/*
* There could be more bits than blocks, eg 512K disk with 512 blocks.
*/
if (bits_per_block > (rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE))
ffc12b98: 7f 89 58 40 cmplw cr7,r9,r11 <== NOT EXECUTED
ffc12b9c: 40 9d 00 08 ble- cr7,ffc12ba4 <rtems_rfs_format+0x624> <== NOT EXECUTED
bits_per_block = rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE;
ffc12ba0: 7d 60 5b 78 mr r0,r11 <== NOT EXECUTED
return ((blocks + 1) * 100 * 10) / bits_per_block;
ffc12ba4: 7c 0a 03 d6 divw r0,r10,r0 <== NOT EXECUTED
printf ("rtems-rfs: format: block size = %zu\n",
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
ffc12ba8: 3c c0 66 66 lis r6,26214 <== NOT EXECUTED
ffc12bac: 60 c6 66 67 ori r6,r6,26215 <== NOT EXECUTED
ffc12bb0: 7c c0 30 96 mulhw r6,r0,r6 <== NOT EXECUTED
ffc12bb4: 7c 09 fe 70 srawi r9,r0,31 <== NOT EXECUTED
ffc12bb8: 7c c6 16 70 srawi r6,r6,2 <== NOT EXECUTED
ffc12bbc: 7c c9 30 50 subf r6,r9,r6 <== NOT EXECUTED
ffc12bc0: 1c c6 00 0a mulli r6,r6,10 <== NOT EXECUTED
ffc12bc4: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc12bc8: 7c c6 00 50 subf r6,r6,r0 <== NOT EXECUTED
ffc12bcc: 38 63 b1 50 addi r3,r3,-20144 <== NOT EXECUTED
ffc12bd0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc12bd4: 48 01 81 71 bl ffc2ad44 <printf> <== NOT EXECUTED
fs.group_inodes * fs.group_count,
rtems_rfs_inode_overhead (&fs) / 10,
rtems_rfs_inode_overhead (&fs) % 10);
printf ("rtems-rfs: format: groups = %u\n", fs.group_count);
ffc12bd8: 80 81 00 7c lwz r4,124(r1) <== NOT EXECUTED
ffc12bdc: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc12be0: 38 63 b1 7c addi r3,r3,-20100 <== NOT EXECUTED
ffc12be4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc12be8: 48 01 81 5d bl ffc2ad44 <printf> <== NOT EXECUTED
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
ffc12bec: 80 81 00 80 lwz r4,128(r1) <== NOT EXECUTED
ffc12bf0: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc12bf4: 38 63 b1 9c addi r3,r3,-20068 <== NOT EXECUTED
ffc12bf8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc12bfc: 48 01 81 49 bl ffc2ad44 <printf> <== NOT EXECUTED
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
ffc12c00: 80 81 00 84 lwz r4,132(r1) <== NOT EXECUTED
ffc12c04: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc12c08: 38 63 b1 c4 addi r3,r3,-20028 <== NOT EXECUTED
ffc12c0c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc12c10: 48 01 81 35 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc12c14: 83 e1 00 64 lwz r31,100(r1) <== NOT EXECUTED
ffc12c18: 4b ff fb 28 b ffc12740 <rtems_rfs_format+0x1c0> <== NOT EXECUTED
int inode_overhead = RTEMS_RFS_INODE_OVERHEAD_PERCENTAGE;
/*
* The number of inodes per group is set as a percentage.
*/
if (config->inode_overhead)
ffc12c1c: 81 5d 00 0c lwz r10,12(r29)
ffc12c20: 39 60 00 01 li r11,1
ffc12c24: 2f 8a 00 00 cmpwi cr7,r10,0
ffc12c28: 41 9e 00 08 beq- cr7,ffc12c30 <rtems_rfs_format+0x6b0> <== ALWAYS TAKEN
ffc12c2c: 7d 4b 53 78 mr r11,r10 <== NOT EXECUTED
static int
rtems_rfs_inodes_from_percent (rtems_rfs_file_system* fs,
int percentage)
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
ffc12c30: 38 84 ff ff addi r4,r4,-1
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
ffc12c34: 7d 6b 21 d6 mullw r11,r11,r4
ffc12c38: 3d 40 51 eb lis r10,20971
ffc12c3c: 61 4a 85 1f ori r10,r10,34079
ffc12c40: 7d 4b 50 16 mulhwu r10,r11,r10
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
ffc12c44: 39 60 00 01 li r11,1
ffc12c48: 55 4a d9 7f rlwinm. r10,r10,27,5,31
ffc12c4c: 40 82 00 cc bne- ffc12d18 <rtems_rfs_format+0x798> <== ALWAYS TAKEN
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
ffc12c50: 3c 00 24 92 lis r0,9362 <== NOT EXECUTED
ffc12c54: 57 ea e8 fe rlwinm r10,r31,29,3,31 <== NOT EXECUTED
ffc12c58: 60 00 49 25 ori r0,r0,18725 <== NOT EXECUTED
ffc12c5c: 7c 0a 00 16 mulhwu r0,r10,r0 <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
ffc12c60: 39 40 00 01 li r10,1 <== NOT EXECUTED
ffc12c64: 7d 6b 01 d7 mullw. r11,r11,r0 <== NOT EXECUTED
}
/*
* Round up to fill a block because the minimum allocation unit is a block.
*/
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
ffc12c68: 90 01 00 88 stw r0,136(r1) <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
ffc12c6c: 41 82 fa 9c beq+ ffc12708 <rtems_rfs_format+0x188> <== NOT EXECUTED
ffc12c70: 4b ff fa 8c b ffc126fc <rtems_rfs_format+0x17c> <== NOT EXECUTED
{
uint64_t total_size = rtems_rfs_fs_media_size (fs);
if (total_size >= GIGS (1))
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
ffc12c74: 3c 04 00 10 addis r0,r4,16 <== NOT EXECUTED
ffc12c78: 7c 84 00 10 subfc r4,r4,r0 <== NOT EXECUTED
ffc12c7c: 7c 84 21 10 subfe r4,r4,r4 <== NOT EXECUTED
ffc12c80: 7c 84 18 50 subf r4,r4,r3 <== NOT EXECUTED
ffc12c84: 54 00 65 3e rlwinm r0,r0,12,20,31 <== NOT EXECUTED
ffc12c88: 54 8b 60 26 rlwinm r11,r4,12,0,19 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
ffc12c8c: 39 20 00 1f li r9,31 <== NOT EXECUTED
{
uint64_t total_size = rtems_rfs_fs_media_size (fs);
if (total_size >= GIGS (1))
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
ffc12c90: 7d 6b 03 78 or r11,r11,r0 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
ffc12c94: 7d 29 03 a6 mtctr r9 <== NOT EXECUTED
ffc12c98: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc12c9c: 48 00 00 08 b ffc12ca4 <rtems_rfs_format+0x724> <== NOT EXECUTED
if (total_size >= GIGS (1))
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
int b;
for (b = 31; b > 0; b--)
ffc12ca0: 42 40 06 0c bdz- ffc132ac <rtems_rfs_format+0xd2c> <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
ffc12ca4: 7c 04 48 30 slw r4,r0,r9 <== NOT EXECUTED
ffc12ca8: 7c 8a 58 39 and. r10,r4,r11 <== NOT EXECUTED
if (total_size >= GIGS (1))
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
int b;
for (b = 31; b > 0; b--)
ffc12cac: 39 29 ff ff addi r9,r9,-1 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
ffc12cb0: 41 82 ff f0 beq+ ffc12ca0 <rtems_rfs_format+0x720> <== NOT EXECUTED
break;
fs->block_size = 1 << b;
ffc12cb4: 90 81 00 64 stw r4,100(r1) <== NOT EXECUTED
}
if (fs->block_size < 512)
ffc12cb8: 2b 84 01 ff cmplwi cr7,r4,511 <== NOT EXECUTED
ffc12cbc: 40 bd fd 6c ble- cr7,ffc12a28 <rtems_rfs_format+0x4a8> <== NOT EXECUTED
fs->block_size = 512;
if (fs->block_size > (4 * 1024))
ffc12cc0: 2b 84 10 00 cmplwi cr7,r4,4096 <== NOT EXECUTED
ffc12cc4: 40 9d 00 10 ble- cr7,ffc12cd4 <rtems_rfs_format+0x754> <== NOT EXECUTED
fs->block_size = (4 * 1024);
ffc12cc8: 38 00 10 00 li r0,4096 <== NOT EXECUTED
ffc12ccc: 90 01 00 64 stw r0,100(r1) <== NOT EXECUTED
ffc12cd0: 38 80 10 00 li r4,4096 <== NOT EXECUTED
ffc12cd4: 81 21 00 68 lwz r9,104(r1) <== NOT EXECUTED
ffc12cd8: 80 a9 00 24 lwz r5,36(r9) <== NOT EXECUTED
ffc12cdc: 4b ff f9 9c b ffc12678 <rtems_rfs_format+0xf8> <== NOT EXECUTED
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
return 1;
return ((dividend - 1) / divisor) + 1;
ffc12ce0: 38 c7 ff ff addi r6,r7,-1 <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
bits_per_block = rtems_rfs_bits_per_block (fs);
/*
* There could be more bits than blocks, eg 512K disk with 512 blocks.
*/
if (bits_per_block > (rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE))
ffc12ce4: 81 61 00 60 lwz r11,96(r1) <== NOT EXECUTED
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
return 1;
return ((dividend - 1) / divisor) + 1;
ffc12ce8: 7c c6 43 96 divwu r6,r6,r8 <== NOT EXECUTED
* Return the number of bits that fit in the block size.
*/
static int
rtems_rfs_bits_per_block (rtems_rfs_file_system* fs)
{
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
ffc12cec: 55 09 18 38 rlwinm r9,r8,3,0,28 <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
bits_per_block = rtems_rfs_bits_per_block (fs);
/*
* There could be more bits than blocks, eg 512K disk with 512 blocks.
*/
if (bits_per_block > (rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE))
ffc12cf0: 39 6b ff ff addi r11,r11,-1 <== NOT EXECUTED
ffc12cf4: 7f 09 58 40 cmplw cr6,r9,r11 <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
ffc12cf8: 38 c6 00 02 addi r6,r6,2 <== NOT EXECUTED
ffc12cfc: 1c c6 03 e8 mulli r6,r6,1000 <== NOT EXECUTED
* Return the number of bits that fit in the block size.
*/
static int
rtems_rfs_bits_per_block (rtems_rfs_file_system* fs)
{
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
ffc12d00: 7d 20 4b 78 mr r0,r9 <== NOT EXECUTED
{
int blocks;
int bits_per_block;
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
rtems_rfs_fs_block_size (fs));
bits_per_block = rtems_rfs_bits_per_block (fs);
ffc12d04: 7d 2a 4b 78 mr r10,r9 <== NOT EXECUTED
/*
* There could be more bits than blocks, eg 512K disk with 512 blocks.
*/
if (bits_per_block > (rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE))
ffc12d08: 40 b9 fe 60 ble- cr6,ffc12b68 <rtems_rfs_format+0x5e8> <== NOT EXECUTED
ffc12d0c: 4b ff fe 58 b ffc12b64 <rtems_rfs_format+0x5e4> <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
ffc12d10: 39 40 07 d0 li r10,2000 <== NOT EXECUTED
ffc12d14: 4b ff fe 84 b ffc12b98 <rtems_rfs_format+0x618> <== NOT EXECUTED
return 1;
return ((dividend - 1) / divisor) + 1;
ffc12d18: 39 6a ff ff addi r11,r10,-1
ffc12d1c: 7d 6b 03 96 divwu r11,r11,r0
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
ffc12d20: 3c 00 24 92 lis r0,9362
ffc12d24: 57 ea e8 fe rlwinm r10,r31,29,3,31
ffc12d28: 60 00 49 25 ori r0,r0,18725
ffc12d2c: 7c 0a 00 16 mulhwu r0,r10,r0
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
return 1;
return ((dividend - 1) / divisor) + 1;
ffc12d30: 39 6b 00 01 addi r11,r11,1
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
ffc12d34: 7d 6b 01 d7 mullw. r11,r11,r0
}
/*
* Round up to fill a block because the minimum allocation unit is a block.
*/
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
ffc12d38: 90 01 00 88 stw r0,136(r1)
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
ffc12d3c: 39 40 00 01 li r10,1
ffc12d40: 41 82 f9 c8 beq+ ffc12708 <rtems_rfs_format+0x188> <== NEVER TAKEN
ffc12d44: 4b ff f9 b8 b ffc126fc <rtems_rfs_format+0x17c>
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc12d48: 38 61 00 5c addi r3,r1,92
ffc12d4c: 38 81 00 10 addi r4,r1,16
ffc12d50: 48 00 f8 f1 bl ffc22640 <rtems_rfs_buffer_handle_release>
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
ffc12d54: 80 01 00 7c lwz r0,124(r1)
handle->dirty = false;
ffc12d58: 9b e1 00 10 stb r31,16(r1)
ffc12d5c: 2f 80 00 00 cmpwi cr7,r0,0
handle->bnum = 0;
ffc12d60: 93 e1 00 14 stw r31,20(r1)
handle->buffer = NULL;
ffc12d64: 93 e1 00 18 stw r31,24(r1)
ffc12d68: 40 9d 02 68 ble- cr7,ffc12fd0 <rtems_rfs_format+0xa50> <== NEVER TAKEN
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
ffc12d6c: 81 21 00 60 lwz r9,96(r1)
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
ffc12d70: 8b 3d 00 14 lbz r25,20(r29)
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
ffc12d74: 2f 89 00 00 cmpwi cr7,r9,0
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
ffc12d78: 88 1d 00 15 lbz r0,21(r29)
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
ffc12d7c: 83 e1 00 80 lwz r31,128(r1)
if (group_base > rtems_rfs_fs_blocks (fs))
ffc12d80: 41 9e 07 14 beq- cr7,ffc13494 <rtems_rfs_format+0xf14> <== NEVER TAKEN
*/
if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))
group_size = rtems_rfs_fs_blocks (fs) - group_base;
if (verbose)
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
ffc12d84: 3e 80 ff c4 lis r20,-60
rc, strerror (rc));
return false;
}
if (verbose)
printf (", blocks");
ffc12d88: 3e a0 ff c4 lis r21,-60
}
rtems_rfs_buffer_mark_dirty (&handle);
if (verbose)
printf (", inodes");
ffc12d8c: 3e 40 ff c4 lis r18,-60
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
ffc12d90: 3b c0 00 01 li r30,1
ffc12d94: 3b 60 00 00 li r27,0
ffc12d98: 3b 80 00 00 li r28,0
*/
if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))
group_size = rtems_rfs_fs_blocks (fs) - group_base;
if (verbose)
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
ffc12d9c: 3a 94 b3 00 addi r20,r20,-19712
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc12da0: 3a c0 00 00 li r22,0
handle->bnum = 0;
ffc12da4: 3b 00 00 00 li r24,0
rc, strerror (rc));
return false;
}
if (verbose)
printf (", blocks");
ffc12da8: 3a b5 b3 38 addi r21,r21,-19656
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
group, rc, strerror (rc));
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
ffc12dac: 3a 60 00 01 li r19,1
if (verbose)
printf (", inodes");
ffc12db0: 3a 52 b4 20 addi r18,r18,-19424
/*
* Be nice to strange sizes of disks. These are embedded systems after all
* and nice numbers do not always work out. Let the last block pick up the
* remainder of the blocks.
*/
if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))
ffc12db4: 7d 7f f2 14 add r11,r31,r30
ffc12db8: 7f 89 58 40 cmplw cr7,r9,r11
ffc12dbc: 40 9c 00 08 bge- cr7,ffc12dc4 <rtems_rfs_format+0x844> <== NEVER TAKEN
group_size = rtems_rfs_fs_blocks (fs) - group_base;
ffc12dc0: 7f fe 48 50 subf r31,r30,r9
if (verbose)
ffc12dc4: 2e 00 00 00 cmpwi cr4,r0,0
ffc12dc8: 40 92 00 f4 bne- cr4,ffc12ebc <rtems_rfs_format+0x93c> <== NEVER TAKEN
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc12dcc: 98 01 00 10 stb r0,16(r1)
handle->bnum = 0;
ffc12dd0: 90 01 00 14 stw r0,20(r1)
handle->buffer = NULL;
ffc12dd4: 90 01 00 18 stw r0,24(r1)
printf (", blocks");
/*
* Open the block bitmap using the new buffer.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
ffc12dd8: 38 61 00 1c addi r3,r1,28
ffc12ddc: 38 81 00 5c addi r4,r1,92
ffc12de0: 38 a1 00 10 addi r5,r1,16
ffc12de4: 7f e6 fb 78 mr r6,r31
ffc12de8: 7f c7 f3 78 mr r7,r30
ffc12dec: 48 00 e1 5d bl ffc20f48 <rtems_rfs_bitmap_open>
group_base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
ffc12df0: 7c 7a 1b 79 mr. r26,r3
ffc12df4: 40 81 00 50 ble- ffc12e44 <rtems_rfs_format+0x8c4> <== ALWAYS TAKEN
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc12df8: 38 81 00 10 addi r4,r1,16 <== NOT EXECUTED
ffc12dfc: 38 61 00 5c addi r3,r1,92 <== NOT EXECUTED
ffc12e00: 48 00 f8 41 bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
ffc12e04: 38 00 00 00 li r0,0 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc12e08: 39 20 00 00 li r9,0 <== NOT EXECUTED
handle->bnum = 0;
ffc12e0c: 90 01 00 14 stw r0,20(r1) <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n",
ffc12e10: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc12e14: 99 21 00 10 stb r9,16(r1) <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
ffc12e18: 90 01 00 18 stw r0,24(r1) <== NOT EXECUTED
ffc12e1c: 48 01 8c 95 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc12e20: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc12e24: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc12e28: 38 63 b3 44 addi r3,r3,-19644 <== NOT EXECUTED
ffc12e2c: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc12e30: 7f 45 d3 78 mr r5,r26 <== NOT EXECUTED
ffc12e34: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc12e38: 48 01 7f 0d bl ffc2ad44 <printf> <== NOT EXECUTED
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
ffc12e3c: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc12e40: 4b ff f9 a8 b ffc127e8 <rtems_rfs_format+0x268> <== NOT EXECUTED
/*
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
ffc12e44: 81 21 00 18 lwz r9,24(r1)
ffc12e48: 38 80 00 ff li r4,255
ffc12e4c: 80 a1 00 64 lwz r5,100(r1)
ffc12e50: 80 69 00 24 lwz r3,36(r9)
ffc12e54: 48 01 7d 61 bl ffc2abb4 <memset>
/*
* Clear the bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
ffc12e58: 38 61 00 1c addi r3,r1,28
ffc12e5c: 48 00 dd c1 bl ffc20c1c <rtems_rfs_bitmap_map_clear_all>
if (rc > 0)
ffc12e60: 7c 7a 1b 79 mr. r26,r3
ffc12e64: 40 81 00 8c ble- ffc12ef0 <rtems_rfs_format+0x970> <== ALWAYS TAKEN
{
rtems_rfs_bitmap_close (&bitmap);
ffc12e68: 38 61 00 1c addi r3,r1,28 <== NOT EXECUTED
ffc12e6c: 48 00 e1 4d bl ffc20fb8 <rtems_rfs_bitmap_close> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc12e70: 38 81 00 10 addi r4,r1,16 <== NOT EXECUTED
ffc12e74: 38 61 00 5c addi r3,r1,92 <== NOT EXECUTED
ffc12e78: 48 00 f7 c9 bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
ffc12e7c: 38 00 00 00 li r0,0 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc12e80: 39 20 00 00 li r9,0 <== NOT EXECUTED
handle->bnum = 0;
ffc12e84: 90 01 00 14 stw r0,20(r1) <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: block bitmap clear all failed: %d: %s\n",
ffc12e88: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc12e8c: 99 21 00 10 stb r9,16(r1) <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
ffc12e90: 90 01 00 18 stw r0,24(r1) <== NOT EXECUTED
ffc12e94: 48 01 8c 1d bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc12e98: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc12e9c: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc12ea0: 38 63 b3 8c addi r3,r3,-19572 <== NOT EXECUTED
ffc12ea4: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc12ea8: 7f 45 d3 78 mr r5,r26 <== NOT EXECUTED
ffc12eac: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc12eb0: 48 01 7e 95 bl ffc2ad44 <printf> <== NOT EXECUTED
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
ffc12eb4: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc12eb8: 4b ff f9 30 b ffc127e8 <rtems_rfs_format+0x268> <== NOT EXECUTED
*/
if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))
group_size = rtems_rfs_fs_blocks (fs) - group_base;
if (verbose)
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
ffc12ebc: 7e 83 a3 78 mr r3,r20 <== NOT EXECUTED
ffc12ec0: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc12ec4: 7f c5 f3 78 mr r5,r30 <== NOT EXECUTED
ffc12ec8: 7f e6 fb 78 mr r6,r31 <== NOT EXECUTED
ffc12ecc: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc12ed0: 48 01 7e 75 bl ffc2ad44 <printf> <== NOT EXECUTED
rc, strerror (rc));
return false;
}
if (verbose)
printf (", blocks");
ffc12ed4: 7e a3 ab 78 mr r3,r21 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc12ed8: 9a c1 00 10 stb r22,16(r1) <== NOT EXECUTED
handle->bnum = 0;
ffc12edc: 93 01 00 14 stw r24,20(r1) <== NOT EXECUTED
handle->buffer = NULL;
ffc12ee0: 93 01 00 18 stw r24,24(r1) <== NOT EXECUTED
ffc12ee4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc12ee8: 48 01 7e 5d bl ffc2ad44 <printf> <== NOT EXECUTED
ffc12eec: 4b ff fe ec b ffc12dd8 <rtems_rfs_format+0x858> <== NOT EXECUTED
}
/*
* Forced allocation of the block bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
ffc12ef0: 38 80 00 00 li r4,0
ffc12ef4: 38 61 00 1c addi r3,r1,28
ffc12ef8: 48 00 da 31 bl ffc20928 <rtems_rfs_bitmap_map_set>
/*
* Forced allocation of the inode bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
ffc12efc: 38 61 00 1c addi r3,r1,28
ffc12f00: 38 80 00 01 li r4,1
ffc12f04: 48 00 da 25 bl ffc20928 <rtems_rfs_bitmap_map_set>
/*
* Determine the number of inodes blocks in the group.
*/
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
ffc12f08: 81 21 00 84 lwz r9,132(r1)
ffc12f0c: 80 01 00 88 lwz r0,136(r1)
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
ffc12f10: 2f 89 00 00 cmpwi cr7,r9,0
ffc12f14: 40 9e 00 a8 bne- cr7,ffc12fbc <rtems_rfs_format+0xa3c> <== ALWAYS TAKEN
return 1;
ffc12f18: 3b 40 00 01 li r26,1 <== NOT EXECUTED
ffc12f1c: 3a 20 00 00 li r17,0
/*
* Forced allocation of the inode blocks which follow the block bitmap.
*/
for (b = 0; b < blocks; b++)
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
ffc12f20: 38 91 00 02 addi r4,r17,2
ffc12f24: 38 61 00 1c addi r3,r1,28
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
/*
* Forced allocation of the inode blocks which follow the block bitmap.
*/
for (b = 0; b < blocks; b++)
ffc12f28: 3a 31 00 01 addi r17,r17,1
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
ffc12f2c: 48 00 d9 fd bl ffc20928 <rtems_rfs_bitmap_map_set>
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
/*
* Forced allocation of the inode blocks which follow the block bitmap.
*/
for (b = 0; b < blocks; b++)
ffc12f30: 7f 9a 88 00 cmpw cr7,r26,r17
ffc12f34: 41 9d ff ec bgt+ cr7,ffc12f20 <rtems_rfs_format+0x9a0>
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
/*
* Close the block bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
ffc12f38: 38 61 00 1c addi r3,r1,28
ffc12f3c: 48 00 e0 7d bl ffc20fb8 <rtems_rfs_bitmap_close>
if (rc > 0)
ffc12f40: 7c 71 1b 79 mr. r17,r3
ffc12f44: 41 81 01 08 bgt- ffc1304c <rtems_rfs_format+0xacc> <== NEVER TAKEN
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
group, rc, strerror (rc));
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
ffc12f48: 9a 61 00 10 stb r19,16(r1)
if (verbose)
ffc12f4c: 40 92 01 c4 bne- cr4,ffc13110 <rtems_rfs_format+0xb90> <== NEVER TAKEN
printf (", inodes");
/*
* Open the inode bitmap using the old buffer. Should release any changes.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
ffc12f50: 7f e6 fb 78 mr r6,r31
ffc12f54: 38 61 00 1c addi r3,r1,28
ffc12f58: 38 81 00 5c addi r4,r1,92
ffc12f5c: 38 a1 00 10 addi r5,r1,16
ffc12f60: 38 fb 00 02 addi r7,r27,2
ffc12f64: 48 00 df e5 bl ffc20f48 <rtems_rfs_bitmap_open>
group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
ffc12f68: 7c 7f 1b 79 mr. r31,r3
ffc12f6c: 40 81 01 2c ble- ffc13098 <rtems_rfs_format+0xb18> <== ALWAYS TAKEN
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc12f70: 38 81 00 10 addi r4,r1,16 <== NOT EXECUTED
ffc12f74: 38 61 00 5c addi r3,r1,92 <== NOT EXECUTED
ffc12f78: 48 00 f6 c9 bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
ffc12f7c: 38 00 00 00 li r0,0 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc12f80: 39 20 00 00 li r9,0 <== NOT EXECUTED
handle->bnum = 0;
ffc12f84: 90 01 00 14 stw r0,20(r1) <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
ffc12f88: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc12f8c: 99 21 00 10 stb r9,16(r1) <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
ffc12f90: 90 01 00 18 stw r0,24(r1) <== NOT EXECUTED
ffc12f94: 48 01 8b 1d bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc12f98: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc12f9c: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc12fa0: 38 63 b4 2c addi r3,r3,-19412 <== NOT EXECUTED
ffc12fa4: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc12fa8: 7f e5 fb 78 mr r5,r31 <== NOT EXECUTED
ffc12fac: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc12fb0: 48 01 7d 95 bl ffc2ad44 <printf> <== NOT EXECUTED
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
ffc12fb4: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc12fb8: 4b ff f8 30 b ffc127e8 <rtems_rfs_format+0x268> <== NOT EXECUTED
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
return 1;
return ((dividend - 1) / divisor) + 1;
ffc12fbc: 3b 49 ff ff addi r26,r9,-1
ffc12fc0: 7f 5a 03 96 divwu r26,r26,r0
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
/*
* Forced allocation of the inode blocks which follow the block bitmap.
*/
for (b = 0; b < blocks; b++)
ffc12fc4: 37 5a 00 01 addic. r26,r26,1
ffc12fc8: 41 81 ff 54 bgt+ ffc12f1c <rtems_rfs_format+0x99c> <== ALWAYS TAKEN
ffc12fcc: 4b ff ff 6c b ffc12f38 <rtems_rfs_format+0x9b8> <== NOT EXECUTED
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
if (config->verbose)
ffc12fd0: 88 1d 00 15 lbz r0,21(r29)
ffc12fd4: 2f 80 00 00 cmpwi cr7,r0,0
ffc12fd8: 40 9e 01 94 bne- cr7,ffc1316c <rtems_rfs_format+0xbec> <== NEVER TAKEN
printf ("\n");
rc = rtems_rfs_buffer_close (&fs);
ffc12fdc: 38 61 00 5c addi r3,r1,92
ffc12fe0: 48 01 00 05 bl ffc22fe4 <rtems_rfs_buffer_close>
if (rc > 0)
ffc12fe4: 7c 7f 1b 79 mr. r31,r3
ffc12fe8: 41 81 04 08 bgt- ffc133f0 <rtems_rfs_format+0xe70> <== NEVER TAKEN
int rc;
/*
* External API so returns -1.
*/
rc = rtems_rfs_fs_open (name, NULL, RTEMS_RFS_FS_FORCE_OPEN, &fs);
ffc12fec: 7e e3 bb 78 mr r3,r23
ffc12ff0: 38 80 00 00 li r4,0
ffc12ff4: 38 a0 00 04 li r5,4
ffc12ff8: 38 c1 00 0c addi r6,r1,12
ffc12ffc: 48 01 29 49 bl ffc25944 <rtems_rfs_fs_open>
if (rc < 0)
ffc13000: 2f 83 00 00 cmpwi cr7,r3,0
ffc13004: 41 9c 04 cc blt- cr7,ffc134d0 <rtems_rfs_format+0xf50> <== NEVER TAKEN
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
errno, strerror (errno));
return -1;
}
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
ffc13008: 80 61 00 0c lwz r3,12(r1)
ffc1300c: 38 80 00 01 li r4,1
ffc13010: 38 a1 00 08 addi r5,r1,8
ffc13014: 48 00 0e 8d bl ffc13ea0 <rtems_rfs_inode_alloc>
if (rc > 0)
ffc13018: 7c 7f 1b 79 mr. r31,r3
ffc1301c: 41 81 01 04 bgt- ffc13120 <rtems_rfs_format+0xba0> <== NEVER TAKEN
rc, strerror (rc));
rtems_rfs_fs_close (fs);
return rc;
}
if (ino != RTEMS_RFS_ROOT_INO)
ffc13020: 80 81 00 08 lwz r4,8(r1)
ffc13024: 2f 84 00 01 cmpwi cr7,r4,1
ffc13028: 41 9e 01 74 beq- cr7,ffc1319c <rtems_rfs_format+0xc1c> <== ALWAYS TAKEN
{
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
ffc1302c: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc13030: 38 63 b5 e8 addi r3,r3,-18968 <== NOT EXECUTED
ffc13034: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc13038: 48 01 7d 0d bl ffc2ad44 <printf> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
ffc1303c: 80 61 00 0c lwz r3,12(r1) <== NOT EXECUTED
ffc13040: 48 01 32 21 bl ffc26260 <rtems_rfs_fs_close> <== NOT EXECUTED
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
rc, strerror (rc));
return -1;
}
return 0;
ffc13044: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc13048: 4b ff f7 a0 b ffc127e8 <rtems_rfs_format+0x268> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc1304c: 38 81 00 10 addi r4,r1,16 <== NOT EXECUTED
ffc13050: 38 61 00 5c addi r3,r1,92 <== NOT EXECUTED
ffc13054: 48 00 f5 ed bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
ffc13058: 38 00 00 00 li r0,0 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc1305c: 39 20 00 00 li r9,0 <== NOT EXECUTED
handle->bnum = 0;
ffc13060: 90 01 00 14 stw r0,20(r1) <== NOT EXECUTED
*/
rc = rtems_rfs_bitmap_close (&bitmap);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
ffc13064: 7e 23 8b 78 mr r3,r17 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc13068: 99 21 00 10 stb r9,16(r1) <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
ffc1306c: 90 01 00 18 stw r0,24(r1) <== NOT EXECUTED
ffc13070: 48 01 8a 41 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc13074: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc13078: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc1307c: 38 63 b3 d8 addi r3,r3,-19496 <== NOT EXECUTED
ffc13080: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc13084: 7e 25 8b 78 mr r5,r17 <== NOT EXECUTED
ffc13088: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1308c: 48 01 7c b9 bl ffc2ad44 <printf> <== NOT EXECUTED
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
ffc13090: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc13094: 4b ff f7 54 b ffc127e8 <rtems_rfs_format+0x268> <== NOT EXECUTED
/*
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0x00, rtems_rfs_fs_block_size (fs));
ffc13098: 81 21 00 18 lwz r9,24(r1)
ffc1309c: 38 80 00 00 li r4,0
ffc130a0: 80 a1 00 64 lwz r5,100(r1)
ffc130a4: 80 69 00 24 lwz r3,36(r9)
ffc130a8: 48 01 7b 0d bl ffc2abb4 <memset>
/*
* Clear the inode bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
ffc130ac: 38 61 00 1c addi r3,r1,28
ffc130b0: 48 00 db 6d bl ffc20c1c <rtems_rfs_bitmap_map_clear_all>
if (rc > 0)
ffc130b4: 7c 7f 1b 79 mr. r31,r3
{
rtems_rfs_bitmap_close (&bitmap);
ffc130b8: 38 61 00 1c addi r3,r1,28
/*
* Clear the inode bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
if (rc > 0)
ffc130bc: 40 81 01 34 ble- ffc131f0 <rtems_rfs_format+0xc70> <== ALWAYS TAKEN
{
rtems_rfs_bitmap_close (&bitmap);
ffc130c0: 48 00 de f9 bl ffc20fb8 <rtems_rfs_bitmap_close> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc130c4: 38 81 00 10 addi r4,r1,16 <== NOT EXECUTED
ffc130c8: 38 61 00 5c addi r3,r1,92 <== NOT EXECUTED
ffc130cc: 48 00 f5 75 bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
ffc130d0: 38 00 00 00 li r0,0 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc130d4: 39 20 00 00 li r9,0 <== NOT EXECUTED
handle->bnum = 0;
ffc130d8: 90 01 00 14 stw r0,20(r1) <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \
ffc130dc: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc130e0: 99 21 00 10 stb r9,16(r1) <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
ffc130e4: 90 01 00 18 stw r0,24(r1) <== NOT EXECUTED
ffc130e8: 48 01 89 c9 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc130ec: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc130f0: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc130f4: 38 63 b4 74 addi r3,r3,-19340 <== NOT EXECUTED
ffc130f8: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc130fc: 7f e5 fb 78 mr r5,r31 <== NOT EXECUTED
ffc13100: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc13104: 48 01 7c 41 bl ffc2ad44 <printf> <== NOT EXECUTED
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
ffc13108: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc1310c: 4b ff f6 dc b ffc127e8 <rtems_rfs_format+0x268> <== NOT EXECUTED
}
rtems_rfs_buffer_mark_dirty (&handle);
if (verbose)
printf (", inodes");
ffc13110: 7e 43 93 78 mr r3,r18 <== NOT EXECUTED
ffc13114: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc13118: 48 01 7c 2d bl ffc2ad44 <printf> <== NOT EXECUTED
ffc1311c: 4b ff fe 34 b ffc12f50 <rtems_rfs_format+0x9d0> <== NOT EXECUTED
}
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
if (rc > 0)
{
printf ("rtems-rfs: format: inode allocation failed: %d: %s\n",
ffc13120: 48 01 89 91 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc13124: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc13128: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc1312c: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc13130: 38 63 b5 b4 addi r3,r3,-19020 <== NOT EXECUTED
ffc13134: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc13138: 48 01 7c 0d bl ffc2ad44 <printf> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_fs_close (fs);
ffc1313c: 80 61 00 0c lwz r3,12(r1) <== NOT EXECUTED
ffc13140: 48 01 31 21 bl ffc26260 <rtems_rfs_fs_close> <== NOT EXECUTED
}
rc = rtems_rfs_write_root_dir (name);
if (rc > 0)
{
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
ffc13144: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc13148: 48 01 89 69 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc1314c: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc13150: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc13154: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc13158: 38 63 b7 20 addi r3,r3,-18656 <== NOT EXECUTED
ffc1315c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc13160: 48 01 7b e5 bl ffc2ad44 <printf> <== NOT EXECUTED
rc, strerror (rc));
return -1;
ffc13164: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc13168: 4b ff f6 80 b ffc127e8 <rtems_rfs_format+0x268> <== NOT EXECUTED
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
if (config->verbose)
printf ("\n");
ffc1316c: 38 60 00 0a li r3,10 <== NOT EXECUTED
ffc13170: 48 01 7c 91 bl ffc2ae00 <putchar> <== NOT EXECUTED
ffc13174: 4b ff fe 68 b ffc12fdc <rtems_rfs_format+0xa5c> <== NOT EXECUTED
}
rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
if (rc > 0)
{
printf ("rtems-rfs: format: setting block size failed: %d: %s\n",
ffc13178: 48 01 89 39 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc1317c: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc13180: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc13184: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc13188: 38 63 b1 ec addi r3,r3,-19988 <== NOT EXECUTED
ffc1318c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc13190: 48 01 7b b5 bl ffc2ad44 <printf> <== NOT EXECUTED
rc, strerror (rc));
return -1;
ffc13194: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc13198: 4b ff f6 50 b ffc127e8 <rtems_rfs_format+0x268> <== NOT EXECUTED
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
rtems_rfs_fs_close (fs);
return rc;
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc1319c: 80 61 00 0c lwz r3,12(r1)
ffc131a0: 38 80 00 01 li r4,1
ffc131a4: 38 a1 00 34 addi r5,r1,52
ffc131a8: 38 c0 00 01 li r6,1
ffc131ac: 48 00 0e 2d bl ffc13fd8 <rtems_rfs_inode_open>
if (rc > 0)
ffc131b0: 7c 7f 1b 79 mr. r31,r3
ffc131b4: 40 81 01 50 ble- ffc13304 <rtems_rfs_format+0xd84> <== ALWAYS TAKEN
{
printf ("rtems-rfs: format: inode open failed: %d: %s\n",
ffc131b8: 48 01 88 f9 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc131bc: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc131c0: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc131c4: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc131c8: 38 63 b6 20 addi r3,r3,-18912 <== NOT EXECUTED
ffc131cc: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc131d0: 48 01 7b 75 bl ffc2ad44 <printf> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_group_bitmap_free (fs, true, ino);
ffc131d4: 80 61 00 0c lwz r3,12(r1) <== NOT EXECUTED
ffc131d8: 80 a1 00 08 lwz r5,8(r1) <== NOT EXECUTED
ffc131dc: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc131e0: 48 00 09 7d bl ffc13b5c <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
ffc131e4: 80 61 00 0c lwz r3,12(r1) <== NOT EXECUTED
ffc131e8: 48 01 30 79 bl ffc26260 <rtems_rfs_fs_close> <== NOT EXECUTED
ffc131ec: 4b ff ff 58 b ffc13144 <rtems_rfs_format+0xbc4> <== NOT EXECUTED
}
/*
* Close the inode bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
ffc131f0: 48 00 dd c9 bl ffc20fb8 <rtems_rfs_bitmap_close>
if (rc > 0)
ffc131f4: 7c 7f 1b 79 mr. r31,r3
ffc131f8: 41 81 00 c0 bgt- ffc132b8 <rtems_rfs_format+0xd38> <== NEVER TAKEN
rtems_rfs_buffer_mark_dirty (&handle);
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
ffc131fc: 2f 99 00 00 cmpwi cr7,r25,0
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
" bitmap failed: %d: %s\n", group, rc, strerror (rc));
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
ffc13200: 9a 61 00 10 stb r19,16(r1)
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
ffc13204: 41 9e 02 2c beq- cr7,ffc13430 <rtems_rfs_format+0xeb0> <== ALWAYS TAKEN
{
for (b = 0; b < blocks; b++)
ffc13208: 2f 9a 00 00 cmpwi cr7,r26,0 <== NOT EXECUTED
ffc1320c: 40 9d 02 24 ble- cr7,ffc13430 <rtems_rfs_format+0xeb0> <== NOT EXECUTED
ffc13210: 3b de 00 02 addi r30,r30,2 <== NOT EXECUTED
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
ffc13214: 7f 5e d2 14 add r26,r30,r26 <== NOT EXECUTED
ffc13218: 48 00 00 24 b ffc1323c <rtems_rfs_format+0xcbc> <== NOT EXECUTED
/*
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
ffc1321c: 81 21 00 18 lwz r9,24(r1) <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
ffc13220: 3b de 00 01 addi r30,r30,1 <== NOT EXECUTED
/*
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
ffc13224: 80 a1 00 64 lwz r5,100(r1) <== NOT EXECUTED
ffc13228: 80 69 00 24 lwz r3,36(r9) <== NOT EXECUTED
ffc1322c: 48 01 79 89 bl ffc2abb4 <memset> <== NOT EXECUTED
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
ffc13230: 7f 9e d0 00 cmpw cr7,r30,r26 <== NOT EXECUTED
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
rtems_rfs_buffer_mark_dirty (&handle);
ffc13234: 9a 61 00 10 stb r19,16(r1) <== NOT EXECUTED
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
ffc13238: 41 9e 01 f8 beq- cr7,ffc13430 <rtems_rfs_format+0xeb0> <== NOT EXECUTED
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
ffc1323c: 38 81 00 10 addi r4,r1,16 <== NOT EXECUTED
ffc13240: 7f c5 f3 78 mr r5,r30 <== NOT EXECUTED
ffc13244: 38 c0 00 00 li r6,0 <== NOT EXECUTED
ffc13248: 38 61 00 5c addi r3,r1,92 <== NOT EXECUTED
ffc1324c: 48 00 f6 09 bl ffc22854 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
/*
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
ffc13250: 38 80 00 ff li r4,255 <== NOT EXECUTED
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
false);
if (rc > 0)
ffc13254: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc13258: 40 81 ff c4 ble+ ffc1321c <rtems_rfs_format+0xc9c> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc1325c: 38 81 00 10 addi r4,r1,16 <== NOT EXECUTED
ffc13260: 38 61 00 5c addi r3,r1,92 <== NOT EXECUTED
ffc13264: 48 00 f3 dd bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
ffc13268: 38 00 00 00 li r0,0 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc1326c: 39 20 00 00 li r9,0 <== NOT EXECUTED
handle->bnum = 0;
ffc13270: 90 01 00 14 stw r0,20(r1) <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: block %" PRId32 " request failed: %d: %s\n",
ffc13274: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc13278: 99 21 00 10 stb r9,16(r1) <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
ffc1327c: 90 01 00 18 stw r0,24(r1) <== NOT EXECUTED
ffc13280: 48 01 88 31 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc13284: 7c 67 1b 78 mr r7,r3 <== NOT EXECUTED
ffc13288: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc1328c: 38 63 b5 08 addi r3,r3,-19192 <== NOT EXECUTED
ffc13290: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc13294: 7f c5 f3 78 mr r5,r30 <== NOT EXECUTED
ffc13298: 7f e6 fb 78 mr r6,r31 <== NOT EXECUTED
ffc1329c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc132a0: 48 01 7a a5 bl ffc2ad44 <printf> <== NOT EXECUTED
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
ffc132a4: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc132a8: 4b ff f5 40 b ffc127e8 <rtems_rfs_format+0x268> <== NOT EXECUTED
if (total_size >= GIGS (1))
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
int b;
for (b = 31; b > 0; b--)
ffc132ac: 38 80 00 01 li r4,1 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
break;
fs->block_size = 1 << b;
ffc132b0: 90 81 00 64 stw r4,100(r1) <== NOT EXECUTED
ffc132b4: 4b ff fa 04 b ffc12cb8 <rtems_rfs_format+0x738> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc132b8: 38 81 00 10 addi r4,r1,16 <== NOT EXECUTED
ffc132bc: 38 61 00 5c addi r3,r1,92 <== NOT EXECUTED
ffc132c0: 48 00 f3 81 bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
ffc132c4: 38 00 00 00 li r0,0 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc132c8: 39 20 00 00 li r9,0 <== NOT EXECUTED
handle->bnum = 0;
ffc132cc: 90 01 00 14 stw r0,20(r1) <== NOT EXECUTED
*/
rc = rtems_rfs_bitmap_close (&bitmap);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
ffc132d0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc132d4: 99 21 00 10 stb r9,16(r1) <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
ffc132d8: 90 01 00 18 stw r0,24(r1) <== NOT EXECUTED
ffc132dc: 48 01 87 d5 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc132e0: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc132e4: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc132e8: 38 63 b4 c0 addi r3,r3,-19264 <== NOT EXECUTED
ffc132ec: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc132f0: 7f e5 fb 78 mr r5,r31 <== NOT EXECUTED
ffc132f4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc132f8: 48 01 7a 4d bl ffc2ad44 <printf> <== NOT EXECUTED
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
ffc132fc: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc13300: 4b ff f4 e8 b ffc127e8 <rtems_rfs_format+0x268> <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, true, ino);
rtems_rfs_fs_close (fs);
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, 0,
ffc13304: 38 61 00 34 addi r3,r1,52
ffc13308: 38 80 00 00 li r4,0
ffc1330c: 38 a0 41 c9 li r5,16841
ffc13310: 38 c0 00 00 li r6,0
ffc13314: 38 e0 00 00 li r7,0
ffc13318: 48 00 11 dd bl ffc144f4 <rtems_rfs_inode_initialise>
(RTEMS_RFS_S_IFDIR | RTEMS_RFS_S_IRWXU |
RTEMS_RFS_S_IXGRP | RTEMS_RFS_S_IXOTH),
0, 0);
if (rc > 0)
ffc1331c: 7c 7f 1b 79 mr. r31,r3
ffc13320: 40 81 00 20 ble- ffc13340 <rtems_rfs_format+0xdc0> <== ALWAYS TAKEN
printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",
ffc13324: 48 01 87 8d bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc13328: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc1332c: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc13330: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc13334: 38 63 b6 50 addi r3,r3,-18864 <== NOT EXECUTED
ffc13338: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1333c: 48 01 7a 09 bl ffc2ad44 <printf> <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
ffc13340: 80 61 00 0c lwz r3,12(r1)
ffc13344: 3c a0 ff c4 lis r5,-60
ffc13348: 80 e1 00 08 lwz r7,8(r1)
ffc1334c: 38 81 00 34 addi r4,r1,52
ffc13350: 38 a5 9e 0c addi r5,r5,-25076
ffc13354: 38 c0 00 01 li r6,1
ffc13358: 48 01 03 3d bl ffc23694 <rtems_rfs_dir_add_entry>
if (rc > 0)
ffc1335c: 7c 7f 1b 79 mr. r31,r3
ffc13360: 40 81 00 20 ble- ffc13380 <rtems_rfs_format+0xe00> <== ALWAYS TAKEN
printf ("rtems-rfs: format: directory add failed: %d: %s\n",
ffc13364: 48 01 87 4d bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc13368: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc1336c: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc13370: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc13374: 38 63 b6 84 addi r3,r3,-18812 <== NOT EXECUTED
ffc13378: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1337c: 48 01 79 c9 bl ffc2ad44 <printf> <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_inode_close (fs, &inode);
ffc13380: 80 61 00 0c lwz r3,12(r1)
ffc13384: 38 81 00 34 addi r4,r1,52
ffc13388: 48 00 0e b1 bl ffc14238 <rtems_rfs_inode_close>
if (rc > 0)
ffc1338c: 7c 7f 1b 79 mr. r31,r3
ffc13390: 40 81 00 20 ble- ffc133b0 <rtems_rfs_format+0xe30> <== ALWAYS TAKEN
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
ffc13394: 48 01 87 1d bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc13398: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc1339c: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc133a0: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc133a4: 38 63 b6 b8 addi r3,r3,-18760 <== NOT EXECUTED
ffc133a8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc133ac: 48 01 79 99 bl ffc2ad44 <printf> <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
ffc133b0: 80 61 00 0c lwz r3,12(r1)
ffc133b4: 48 01 2e ad bl ffc26260 <rtems_rfs_fs_close>
if (rc < 0)
ffc133b8: 7c 7f 1b 79 mr. r31,r3
ffc133bc: 41 80 00 e0 blt- ffc1349c <rtems_rfs_format+0xf1c> <== NEVER TAKEN
rc, strerror (rc));
return -1;
}
rc = rtems_rfs_write_root_dir (name);
if (rc > 0)
ffc133c0: 40 a2 fd 84 bne- ffc13144 <rtems_rfs_format+0xbc4> <== NEVER TAKEN
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
rc, strerror (rc));
return -1;
}
return 0;
ffc133c4: 38 60 00 00 li r3,0
ffc133c8: 4b ff f4 20 b ffc127e8 <rtems_rfs_format+0x268>
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
if (rc > 0)
{
printf ("rtems-rfs: format: buffer open failed: %d: %s\n",
ffc133cc: 48 01 86 e5 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc133d0: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc133d4: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc133d8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc133dc: 38 63 af 50 addi r3,r3,-20656 <== NOT EXECUTED
ffc133e0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc133e4: 48 01 79 61 bl ffc2ad44 <printf> <== NOT EXECUTED
rc, strerror (rc));
return -1;
ffc133e8: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc133ec: 4b ff f3 fc b ffc127e8 <rtems_rfs_format+0x268> <== NOT EXECUTED
printf ("\n");
rc = rtems_rfs_buffer_close (&fs);
if (rc > 0)
{
printf ("rtems-rfs: format: buffer close failed: %d: %s\n",
ffc133f0: 48 01 86 c1 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc133f4: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc133f8: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc133fc: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc13400: 38 63 b5 50 addi r3,r3,-19120 <== NOT EXECUTED
ffc13404: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc13408: 48 01 79 3d bl ffc2ad44 <printf> <== NOT EXECUTED
rc, strerror (rc));
return -1;
ffc1340c: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc13410: 4b ff f3 d8 b ffc127e8 <rtems_rfs_format+0x268> <== NOT EXECUTED
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
{
printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",
ffc13414: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc13418: 38 63 af 80 addi r3,r3,-20608 <== NOT EXECUTED
ffc1341c: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc13420: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc13424: 48 01 79 21 bl ffc2ad44 <printf> <== NOT EXECUTED
rtems_rfs_fs_media_block_size (&fs));
return -1;
ffc13428: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc1342c: 4b ff f3 bc b ffc127e8 <rtems_rfs_format+0x268> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc13430: 38 61 00 5c addi r3,r1,92
ffc13434: 38 81 00 10 addi r4,r1,16
ffc13438: 48 00 f2 09 bl ffc22640 <rtems_rfs_buffer_handle_release>
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
ffc1343c: 80 01 00 7c lwz r0,124(r1)
ffc13440: 3b 9c 00 01 addi r28,r28,1
handle->dirty = false;
ffc13444: 9a c1 00 10 stb r22,16(r1)
ffc13448: 7f 80 e0 00 cmpw cr7,r0,r28
handle->bnum = 0;
ffc1344c: 93 01 00 14 stw r24,20(r1)
handle->buffer = NULL;
ffc13450: 93 01 00 18 stw r24,24(r1)
ffc13454: 40 bd fb 7c ble- cr7,ffc12fd0 <rtems_rfs_format+0xa50> <== ALWAYS TAKEN
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
ffc13458: 83 e1 00 80 lwz r31,128(r1) <== NOT EXECUTED
if (group_base > rtems_rfs_fs_blocks (fs))
ffc1345c: 81 21 00 60 lwz r9,96(r1) <== NOT EXECUTED
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
ffc13460: 7f 7c f9 d6 mullw r27,r28,r31 <== NOT EXECUTED
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
ffc13464: 8b 3d 00 14 lbz r25,20(r29) <== NOT EXECUTED
ffc13468: 88 1d 00 15 lbz r0,21(r29) <== NOT EXECUTED
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
ffc1346c: 3b db 00 01 addi r30,r27,1 <== NOT EXECUTED
if (group_base > rtems_rfs_fs_blocks (fs))
ffc13470: 7f 9e 48 40 cmplw cr7,r30,r9 <== NOT EXECUTED
ffc13474: 40 9d f9 40 ble+ cr7,ffc12db4 <rtems_rfs_format+0x834> <== NOT EXECUTED
{
printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
ffc13478: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc1347c: 38 63 b2 c4 addi r3,r3,-19772 <== NOT EXECUTED
ffc13480: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc13484: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc13488: 48 01 78 bd bl ffc2ad44 <printf> <== NOT EXECUTED
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
ffc1348c: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc13490: 4b ff f3 58 b ffc127e8 <rtems_rfs_format+0x268> <== NOT EXECUTED
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
ffc13494: 3b 80 00 00 li r28,0 <== NOT EXECUTED
ffc13498: 4b ff ff e0 b ffc13478 <rtems_rfs_format+0xef8> <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
if (rc < 0)
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
errno, strerror (errno));
ffc1349c: 48 01 67 c5 bl ffc29c60 <__errno> <== NOT EXECUTED
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
if (rc < 0)
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
ffc134a0: 83 e3 00 00 lwz r31,0(r3) <== NOT EXECUTED
errno, strerror (errno));
ffc134a4: 48 01 67 bd bl ffc29c60 <__errno> <== NOT EXECUTED
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
if (rc < 0)
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
ffc134a8: 80 63 00 00 lwz r3,0(r3) <== NOT EXECUTED
ffc134ac: 48 01 86 05 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc134b0: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc134b4: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc134b8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc134bc: 38 63 b6 e8 addi r3,r3,-18712 <== NOT EXECUTED
ffc134c0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc134c4: 48 01 78 81 bl ffc2ad44 <printf> <== NOT EXECUTED
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
rc, strerror (rc));
return -1;
}
return 0;
ffc134c8: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc134cc: 4b ff f3 1c b ffc127e8 <rtems_rfs_format+0x268> <== NOT EXECUTED
*/
rc = rtems_rfs_fs_open (name, NULL, RTEMS_RFS_FS_FORCE_OPEN, &fs);
if (rc < 0)
{
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
errno, strerror (errno));
ffc134d0: 48 01 67 91 bl ffc29c60 <__errno> <== NOT EXECUTED
* External API so returns -1.
*/
rc = rtems_rfs_fs_open (name, NULL, RTEMS_RFS_FS_FORCE_OPEN, &fs);
if (rc < 0)
{
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
ffc134d4: 83 e3 00 00 lwz r31,0(r3) <== NOT EXECUTED
errno, strerror (errno));
ffc134d8: 48 01 67 89 bl ffc29c60 <__errno> <== NOT EXECUTED
* External API so returns -1.
*/
rc = rtems_rfs_fs_open (name, NULL, RTEMS_RFS_FS_FORCE_OPEN, &fs);
if (rc < 0)
{
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
ffc134dc: 80 63 00 00 lwz r3,0(r3) <== NOT EXECUTED
ffc134e0: 48 01 85 d1 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc134e4: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc134e8: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc134ec: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc134f0: 38 63 b5 80 addi r3,r3,-19072 <== NOT EXECUTED
ffc134f4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc134f8: 48 01 78 4d bl ffc2ad44 <printf> <== NOT EXECUTED
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
rc, strerror (rc));
return -1;
}
return 0;
ffc134fc: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc13500: 4b ff f2 e8 b ffc127e8 <rtems_rfs_format+0x268> <== NOT EXECUTED
ffc26260 <rtems_rfs_fs_close>:
return 0;
}
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
ffc26260: 94 21 ff e8 stwu r1,-24(r1)
ffc26264: 7c 08 02 a6 mflr r0
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
ffc26268: 38 80 00 02 li r4,2
return 0;
}
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
ffc2626c: 93 e1 00 14 stw r31,20(r1)
ffc26270: 7c 7f 1b 78 mr r31,r3
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
ffc26274: 38 60 00 00 li r3,0
return 0;
}
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
ffc26278: 90 01 00 1c stw r0,28(r1)
ffc2627c: 93 a1 00 0c stw r29,12(r1)
ffc26280: 93 c1 00 10 stw r30,16(r1)
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
ffc26284: 4b ff 16 e5 bl ffc17968 <rtems_rfs_trace>
ffc26288: 2f 83 00 00 cmpwi cr7,r3,0
ffc2628c: 40 9e 00 6c bne- cr7,ffc262f8 <rtems_rfs_fs_close+0x98> <== NEVER TAKEN
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
ffc26290: 80 1f 00 20 lwz r0,32(r31)
ffc26294: 2f 80 00 00 cmpwi cr7,r0,0
ffc26298: 40 9d 00 30 ble- cr7,ffc262c8 <rtems_rfs_fs_close+0x68> <== NEVER TAKEN
ffc2629c: 3b a0 00 00 li r29,0
ffc262a0: 3b c0 00 00 li r30,0
rtems_rfs_group_close (fs, &fs->groups[group]);
ffc262a4: 80 9f 00 1c lwz r4,28(r31)
ffc262a8: 7f e3 fb 78 mr r3,r31
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
ffc262ac: 3b de 00 01 addi r30,r30,1
rtems_rfs_group_close (fs, &fs->groups[group]);
ffc262b0: 7c 84 ea 14 add r4,r4,r29
ffc262b4: 4b fe d5 19 bl ffc137cc <rtems_rfs_group_close>
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
ffc262b8: 80 1f 00 20 lwz r0,32(r31)
ffc262bc: 3b bd 00 50 addi r29,r29,80
ffc262c0: 7f 80 f0 00 cmpw cr7,r0,r30
ffc262c4: 41 9d ff e0 bgt+ cr7,ffc262a4 <rtems_rfs_fs_close+0x44> <== NEVER TAKEN
rtems_rfs_group_close (fs, &fs->groups[group]);
rtems_rfs_buffer_close (fs);
ffc262c8: 7f e3 fb 78 mr r3,r31
ffc262cc: 4b ff cd 19 bl ffc22fe4 <rtems_rfs_buffer_close>
free (fs);
ffc262d0: 7f e3 fb 78 mr r3,r31
ffc262d4: 4b fe 22 0d bl ffc084e0 <free>
return 0;
}
ffc262d8: 80 01 00 1c lwz r0,28(r1)
ffc262dc: 38 60 00 00 li r3,0
ffc262e0: 83 a1 00 0c lwz r29,12(r1)
ffc262e4: 7c 08 03 a6 mtlr r0
ffc262e8: 83 c1 00 10 lwz r30,16(r1)
ffc262ec: 83 e1 00 14 lwz r31,20(r1)
ffc262f0: 38 21 00 18 addi r1,r1,24
ffc262f4: 4e 80 00 20 blr
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
printf ("rtems-rfs: close\n");
ffc262f8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc262fc: 38 63 da 24 addi r3,r3,-9692 <== NOT EXECUTED
ffc26300: 48 00 4b f9 bl ffc2aef8 <puts> <== NOT EXECUTED
ffc26304: 4b ff ff 8c b ffc26290 <rtems_rfs_fs_close+0x30> <== NOT EXECUTED
ffc25944 <rtems_rfs_fs_open>:
int
rtems_rfs_fs_open (const char* name,
void* user,
uint32_t flags,
rtems_rfs_file_system** fs)
{
ffc25944: 94 21 ff 98 stwu r1,-104(r1)
ffc25948: 7c 08 02 a6 mflr r0
ffc2594c: 93 61 00 54 stw r27,84(r1)
ffc25950: 7c 9b 23 78 mr r27,r4
size_t group_base;
rtems_rfs_inode_handle inode;
uint16_t mode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc25954: 38 80 00 01 li r4,1
int
rtems_rfs_fs_open (const char* name,
void* user,
uint32_t flags,
rtems_rfs_file_system** fs)
{
ffc25958: 93 c1 00 60 stw r30,96(r1)
ffc2595c: 7c 7e 1b 78 mr r30,r3
size_t group_base;
rtems_rfs_inode_handle inode;
uint16_t mode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc25960: 38 60 00 00 li r3,0
int
rtems_rfs_fs_open (const char* name,
void* user,
uint32_t flags,
rtems_rfs_file_system** fs)
{
ffc25964: 93 81 00 58 stw r28,88(r1)
ffc25968: 7c bc 2b 78 mr r28,r5
ffc2596c: 93 e1 00 64 stw r31,100(r1)
ffc25970: 7c df 33 78 mr r31,r6
ffc25974: 90 01 00 6c stw r0,108(r1)
ffc25978: 93 41 00 50 stw r26,80(r1)
ffc2597c: 93 a1 00 5c stw r29,92(r1)
size_t group_base;
rtems_rfs_inode_handle inode;
uint16_t mode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc25980: 4b ff 1f e9 bl ffc17968 <rtems_rfs_trace>
ffc25984: 2f 83 00 00 cmpwi cr7,r3,0
ffc25988: 40 9e 02 00 bne- cr7,ffc25b88 <rtems_rfs_fs_open+0x244> <== NEVER TAKEN
printf ("rtems-rfs: open: %s\n", name);
*fs = malloc (sizeof (rtems_rfs_file_system));
ffc2598c: 38 60 00 80 li r3,128
ffc25990: 4b fe 34 5d bl ffc08dec <malloc>
if (!*fs)
ffc25994: 2f 83 00 00 cmpwi cr7,r3,0
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: open: %s\n", name);
*fs = malloc (sizeof (rtems_rfs_file_system));
ffc25998: 90 7f 00 00 stw r3,0(r31)
if (!*fs)
ffc2599c: 41 9e 05 d0 beq- cr7,ffc25f6c <rtems_rfs_fs_open+0x628> <== NEVER TAKEN
printf ("rtems-rfs: open: no memory for file system data\n");
errno = ENOMEM;
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
ffc259a0: 38 80 00 00 li r4,0
ffc259a4: 38 a0 00 80 li r5,128
ffc259a8: 48 00 52 0d bl ffc2abb4 <memset>
(*fs)->user = user;
ffc259ac: 81 3f 00 00 lwz r9,0(r31)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
ffc259b0: 3b a0 00 00 li r29,0
ffc259b4: 93 69 00 7c stw r27,124(r9)
group_base = 0;
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
ffc259b8: 7f c3 f3 78 mr r3,r30
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
(*fs)->user = user;
rtems_chain_initialize_empty (&(*fs)->buffers);
ffc259bc: 81 3f 00 00 lwz r9,0(r31)
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 );
ffc259c0: 39 69 00 40 addi r11,r9,64
head->next = tail;
head->previous = NULL;
ffc259c4: 93 a9 00 44 stw r29,68(r9)
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 );
ffc259c8: 38 09 00 44 addi r0,r9,68
head->next = tail;
head->previous = NULL;
tail->previous = head;
ffc259cc: 91 69 00 48 stw r11,72(r9)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc259d0: 90 09 00 40 stw r0,64(r9)
rtems_chain_initialize_empty (&(*fs)->release);
ffc259d4: 81 3f 00 00 lwz r9,0(r31)
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 );
ffc259d8: 39 69 00 50 addi r11,r9,80
head->next = tail;
head->previous = NULL;
ffc259dc: 93 a9 00 54 stw r29,84(r9)
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 );
ffc259e0: 38 09 00 54 addi r0,r9,84
head->next = tail;
head->previous = NULL;
tail->previous = head;
ffc259e4: 91 69 00 58 stw r11,88(r9)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc259e8: 90 09 00 50 stw r0,80(r9)
rtems_chain_initialize_empty (&(*fs)->release_modified);
ffc259ec: 81 3f 00 00 lwz r9,0(r31)
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 );
ffc259f0: 39 69 00 60 addi r11,r9,96
head->next = tail;
head->previous = NULL;
ffc259f4: 93 a9 00 64 stw r29,100(r9)
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 );
ffc259f8: 38 09 00 64 addi r0,r9,100
head->next = tail;
head->previous = NULL;
tail->previous = head;
ffc259fc: 91 69 00 68 stw r11,104(r9)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc25a00: 90 09 00 60 stw r0,96(r9)
rtems_chain_initialize_empty (&(*fs)->file_shares);
ffc25a04: 81 3f 00 00 lwz r9,0(r31)
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 );
ffc25a08: 38 09 00 70 addi r0,r9,112
head->next = tail;
head->previous = NULL;
ffc25a0c: 93 a9 00 74 stw r29,116(r9)
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 );
ffc25a10: 39 69 00 74 addi r11,r9,116
head->next = tail;
head->previous = NULL;
tail->previous = head;
ffc25a14: 90 09 00 78 stw r0,120(r9)
(*fs)->max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
ffc25a18: 38 00 00 05 li r0,5
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc25a1c: 91 69 00 70 stw r11,112(r9)
ffc25a20: 81 3f 00 00 lwz r9,0(r31)
ffc25a24: 90 09 00 3c stw r0,60(r9)
group_base = 0;
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
ffc25a28: 7d 24 4b 78 mr r4,r9
rtems_chain_initialize_empty (&(*fs)->release);
rtems_chain_initialize_empty (&(*fs)->release_modified);
rtems_chain_initialize_empty (&(*fs)->file_shares);
(*fs)->max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
(*fs)->buffers_count = 0;
ffc25a2c: 93 a9 00 4c stw r29,76(r9)
(*fs)->release_count = 0;
ffc25a30: 93 a9 00 5c stw r29,92(r9)
(*fs)->release_modified_count = 0;
ffc25a34: 93 a9 00 6c stw r29,108(r9)
(*fs)->flags = flags;
ffc25a38: 93 89 00 00 stw r28,0(r9)
group_base = 0;
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
ffc25a3c: 4b ff d1 29 bl ffc22b64 <rtems_rfs_buffer_open>
if (rc > 0)
ffc25a40: 7c 7e 1b 79 mr. r30,r3
ffc25a44: 41 81 02 a8 bgt- ffc25cec <rtems_rfs_fs_open+0x3a8> <== NEVER TAKEN
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_fs_read_superblock (*fs);
ffc25a48: 83 df 00 00 lwz r30,0(r31)
printf ("rtems-rfs: read-superblock: handle open failed: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, true);
ffc25a4c: 38 81 00 08 addi r4,r1,8
ffc25a50: 38 a0 00 00 li r5,0
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc25a54: 9b a1 00 08 stb r29,8(r1)
ffc25a58: 7f c3 f3 78 mr r3,r30
ffc25a5c: 38 c0 00 01 li r6,1
handle->bnum = 0;
ffc25a60: 93 a1 00 0c stw r29,12(r1)
handle->buffer = NULL;
ffc25a64: 93 a1 00 10 stw r29,16(r1)
ffc25a68: 4b ff cd ed bl ffc22854 <rtems_rfs_buffer_handle_request>
if (rc > 0)
ffc25a6c: 7c 7b 1b 79 mr. r27,r3
ffc25a70: 40 81 00 70 ble- ffc25ae0 <rtems_rfs_fs_open+0x19c> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc25a74: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc25a78: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc25a7c: 4b ff 1e ed bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc25a80: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc25a84: 40 9e 01 3c bne- cr7,ffc25bc0 <rtems_rfs_fs_open+0x27c> <== NOT EXECUTED
}
rc = rtems_rfs_fs_read_superblock (*fs);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
ffc25a88: 80 7f 00 00 lwz r3,0(r31) <== NOT EXECUTED
ffc25a8c: 4b ff d5 59 bl ffc22fe4 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
ffc25a90: 80 7f 00 00 lwz r3,0(r31) <== NOT EXECUTED
ffc25a94: 4b fe 2a 4d bl ffc084e0 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc25a98: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc25a9c: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc25aa0: 4b ff 1e c9 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc25aa4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc25aa8: 40 9e 00 bc bne- cr7,ffc25b64 <rtems_rfs_fs_open+0x220> <== NOT EXECUTED
printf ("rtems-rfs: open: reading superblock: %d: %s\n",
rc, strerror (rc));
errno = rc;
ffc25aac: 48 00 41 b5 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc25ab0: 93 63 00 00 stw r27,0(r3) <== NOT EXECUTED
return -1;
ffc25ab4: 38 60 ff ff li r3,-1 <== NOT EXECUTED
return -1;
}
errno = 0;
return 0;
}
ffc25ab8: 80 01 00 6c lwz r0,108(r1) <== NOT EXECUTED
ffc25abc: 83 41 00 50 lwz r26,80(r1) <== NOT EXECUTED
ffc25ac0: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc25ac4: 83 61 00 54 lwz r27,84(r1) <== NOT EXECUTED
ffc25ac8: 83 81 00 58 lwz r28,88(r1) <== NOT EXECUTED
ffc25acc: 83 a1 00 5c lwz r29,92(r1) <== NOT EXECUTED
ffc25ad0: 83 c1 00 60 lwz r30,96(r1) <== NOT EXECUTED
ffc25ad4: 83 e1 00 64 lwz r31,100(r1) <== NOT EXECUTED
ffc25ad8: 38 21 00 68 addi r1,r1,104 <== NOT EXECUTED
ffc25adc: 4e 80 00 20 blr <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
rc, strerror (rc));
return rc;
}
sb = rtems_rfs_buffer_data (&handle);
ffc25ae0: 81 21 00 10 lwz r9,16(r1)
ffc25ae4: 83 a9 00 24 lwz r29,36(r9)
#define read_sb(_o) rtems_rfs_read_u32 (sb + (_o))
if (read_sb (RTEMS_RFS_SB_OFFSET_MAGIC) != RTEMS_RFS_SB_MAGIC)
ffc25ae8: 89 5d 00 00 lbz r10,0(r29)
ffc25aec: 89 3d 00 01 lbz r9,1(r29)
ffc25af0: 55 4a c0 0e rlwinm r10,r10,24,0,7
ffc25af4: 89 7d 00 03 lbz r11,3(r29)
ffc25af8: 55 29 80 1e rlwinm r9,r9,16,0,15
ffc25afc: 88 1d 00 02 lbz r0,2(r29)
ffc25b00: 7d 49 4b 78 or r9,r10,r9
ffc25b04: 54 00 40 2e rlwinm r0,r0,8,0,23
ffc25b08: 7d 29 5b 78 or r9,r9,r11
ffc25b0c: 7d 29 03 78 or r9,r9,r0
ffc25b10: 6d 20 28 09 xoris r0,r9,10249
ffc25b14: 2f 80 20 01 cmpwi cr7,r0,8193
ffc25b18: 41 9e 00 cc beq- cr7,ffc25be4 <rtems_rfs_fs_open+0x2a0> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc25b1c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc25b20: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc25b24: 4b ff 1e 45 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc25b28: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc25b2c: 40 9e 00 74 bne- cr7,ffc25ba0 <rtems_rfs_fs_open+0x25c> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc25b30: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc25b34: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc25b38: 4b ff cb 09 bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
ffc25b3c: 3b 60 00 05 li r27,5 <== NOT EXECUTED
}
rc = rtems_rfs_fs_read_superblock (*fs);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
ffc25b40: 80 7f 00 00 lwz r3,0(r31) <== NOT EXECUTED
ffc25b44: 4b ff d4 a1 bl ffc22fe4 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
ffc25b48: 80 7f 00 00 lwz r3,0(r31) <== NOT EXECUTED
ffc25b4c: 4b fe 29 95 bl ffc084e0 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc25b50: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc25b54: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc25b58: 4b ff 1e 11 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc25b5c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc25b60: 41 9e ff 4c beq+ cr7,ffc25aac <rtems_rfs_fs_open+0x168> <== NOT EXECUTED
printf ("rtems-rfs: open: reading superblock: %d: %s\n",
ffc25b64: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc25b68: 48 00 5f 49 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc25b6c: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc25b70: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc25b74: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc25b78: 38 63 d9 68 addi r3,r3,-9880 <== NOT EXECUTED
ffc25b7c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc25b80: 48 00 51 c5 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc25b84: 4b ff ff 28 b ffc25aac <rtems_rfs_fs_open+0x168> <== NOT EXECUTED
rtems_rfs_inode_handle inode;
uint16_t mode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: open: %s\n", name);
ffc25b88: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc25b8c: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc25b90: 38 63 d6 fc addi r3,r3,-10500 <== NOT EXECUTED
ffc25b94: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc25b98: 48 00 51 ad bl ffc2ad44 <printf> <== NOT EXECUTED
ffc25b9c: 4b ff fd f0 b ffc2598c <rtems_rfs_fs_open+0x48> <== NOT EXECUTED
#define read_sb(_o) rtems_rfs_read_u32 (sb + (_o))
if (read_sb (RTEMS_RFS_SB_OFFSET_MAGIC) != RTEMS_RFS_SB_MAGIC)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
ffc25ba0: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc25ba4: 38 63 d7 a8 addi r3,r3,-10328 <== NOT EXECUTED
ffc25ba8: 48 00 53 51 bl ffc2aef8 <puts> <== NOT EXECUTED
ffc25bac: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc25bb0: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc25bb4: 4b ff ca 8d bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
ffc25bb8: 3b 60 00 05 li r27,5 <== NOT EXECUTED
ffc25bbc: 4b ff ff 84 b ffc25b40 <rtems_rfs_fs_open+0x1fc> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, true);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
ffc25bc0: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc25bc4: 48 00 5e ed bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc25bc8: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc25bcc: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc25bd0: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc25bd4: 38 63 d7 74 addi r3,r3,-10380 <== NOT EXECUTED
ffc25bd8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc25bdc: 48 00 51 69 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc25be0: 4b ff fe a8 b ffc25a88 <rtems_rfs_fs_open+0x144> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
ffc25be4: 89 5d 00 0c lbz r10,12(r29)
ffc25be8: 89 7d 00 0d lbz r11,13(r29)
ffc25bec: 89 3d 00 0f lbz r9,15(r29)
ffc25bf0: 55 4a c0 0e rlwinm r10,r10,24,0,7
ffc25bf4: 88 1d 00 0e lbz r0,14(r29)
ffc25bf8: 55 6b 80 1e rlwinm r11,r11,16,0,15
ffc25bfc: 7d 4b 5b 78 or r11,r10,r11
ffc25c00: 7d 6b 4b 78 or r11,r11,r9
}
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
ffc25c04: 81 3e 00 0c lwz r9,12(r30)
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
ffc25c08: 54 00 40 2e rlwinm r0,r0,8,0,23
ffc25c0c: 7d 6b 03 78 or r11,r11,r0
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
ffc25c10: 80 c9 00 24 lwz r6,36(r9)
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
ffc25c14: 91 7e 00 04 stw r11,4(r30)
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
ffc25c18: 88 fd 00 08 lbz r7,8(r29)
ffc25c1c: 88 1d 00 09 lbz r0,9(r29)
ffc25c20: 89 1d 00 0b lbz r8,11(r29)
ffc25c24: 54 e7 c0 0e rlwinm r7,r7,24,0,7
ffc25c28: 89 5d 00 0a lbz r10,10(r29)
ffc25c2c: 54 00 80 1e rlwinm r0,r0,16,0,15
ffc25c30: 7c e0 03 78 or r0,r7,r0
}
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
ffc25c34: 80 e9 00 1c lwz r7,28(r9)
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
ffc25c38: 7c 00 43 78 or r0,r0,r8
ffc25c3c: 55 4a 40 2e rlwinm r10,r10,8,0,23
ffc25c40: 7c 00 53 78 or r0,r0,r10
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
uint64_t block_size = rtems_rfs_fs_block_size (fs);
return blocks * block_size;
ffc25c44: 7d 00 58 16 mulhwu r8,r0,r11
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
ffc25c48: 90 1e 00 08 stw r0,8(r30)
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
return media_blocks * media_block_size;
ffc25c4c: 7d 46 38 16 mulhwu r10,r6,r7
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
uint64_t block_size = rtems_rfs_fs_block_size (fs);
return blocks * block_size;
ffc25c50: 7d 20 59 d6 mullw r9,r0,r11
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))
ffc25c54: 7f 88 50 40 cmplw cr7,r8,r10
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
return media_blocks * media_block_size;
ffc25c58: 7d 66 39 d6 mullw r11,r6,r7
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))
ffc25c5c: 41 9d 01 08 bgt- cr7,ffc25d64 <rtems_rfs_fs_open+0x420> <== NEVER TAKEN
ffc25c60: 7f 88 50 00 cmpw cr7,r8,r10
ffc25c64: 41 9e 00 f8 beq- cr7,ffc25d5c <rtems_rfs_fs_open+0x418> <== ALWAYS TAKEN
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
ffc25c68: 89 1d 00 24 lbz r8,36(r29)
ffc25c6c: 89 3d 00 25 lbz r9,37(r29)
ffc25c70: 55 08 c0 0e rlwinm r8,r8,24,0,7
ffc25c74: 89 5d 00 27 lbz r10,39(r29)
ffc25c78: 55 29 80 1e rlwinm r9,r9,16,0,15
ffc25c7c: 89 7d 00 26 lbz r11,38(r29)
ffc25c80: 7d 09 4b 78 or r9,r8,r9
ffc25c84: 7d 29 53 78 or r9,r9,r10
ffc25c88: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc25c8c: 7d 29 5b 78 or r9,r9,r11
ffc25c90: 2f 89 00 38 cmpwi cr7,r9,56
ffc25c94: 41 9e 00 f4 beq- cr7,ffc25d88 <rtems_rfs_fs_open+0x444> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc25c98: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc25c9c: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc25ca0: 4b ff 1c c9 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc25ca4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc25ca8: 41 9e fe 88 beq+ cr7,ffc25b30 <rtems_rfs_fs_open+0x1ec> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
ffc25cac: 88 9d 00 04 lbz r4,4(r29) <== NOT EXECUTED
}
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
ffc25cb0: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
ffc25cb4: 89 7d 00 05 lbz r11,5(r29) <== NOT EXECUTED
}
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
ffc25cb8: 38 a0 00 00 li r5,0 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
ffc25cbc: 89 3d 00 07 lbz r9,7(r29) <== NOT EXECUTED
ffc25cc0: 54 84 c0 0e rlwinm r4,r4,24,0,7 <== NOT EXECUTED
ffc25cc4: 55 6b 80 1e rlwinm r11,r11,16,0,15 <== NOT EXECUTED
ffc25cc8: 88 1d 00 06 lbz r0,6(r29) <== NOT EXECUTED
ffc25ccc: 7c 84 5b 78 or r4,r4,r11 <== NOT EXECUTED
ffc25cd0: 7c 84 4b 78 or r4,r4,r9 <== NOT EXECUTED
ffc25cd4: 54 00 40 2e rlwinm r0,r0,8,0,23 <== NOT EXECUTED
}
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
ffc25cd8: 7c 84 03 78 or r4,r4,r0 <== NOT EXECUTED
ffc25cdc: 38 63 d8 24 addi r3,r3,-10204 <== NOT EXECUTED
ffc25ce0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc25ce4: 48 00 50 61 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc25ce8: 4b ff fe 48 b ffc25b30 <rtems_rfs_fs_open+0x1ec> <== NOT EXECUTED
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
if (rc > 0)
{
free (*fs);
ffc25cec: 80 7f 00 00 lwz r3,0(r31) <== NOT EXECUTED
ffc25cf0: 4b fe 27 f1 bl ffc084e0 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc25cf4: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc25cf8: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc25cfc: 4b ff 1c 6d bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc25d00: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc25d04: 41 be 00 24 beq+ cr7,ffc25d28 <rtems_rfs_fs_open+0x3e4> <== NOT EXECUTED
printf ("rtems-rfs: open: buffer open failed: %d: %s\n",
ffc25d08: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc25d0c: 48 00 5d a5 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc25d10: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc25d14: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc25d18: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc25d1c: 38 63 d7 44 addi r3,r3,-10428 <== NOT EXECUTED
ffc25d20: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc25d24: 48 00 50 21 bl ffc2ad44 <printf> <== NOT EXECUTED
{
rtems_rfs_buffer_close (*fs);
free (*fs);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
errno = rc;
ffc25d28: 48 00 3f 39 bl ffc29c60 <__errno> <== NOT EXECUTED
return -1;
}
errno = 0;
return 0;
}
ffc25d2c: 80 01 00 6c lwz r0,108(r1) <== NOT EXECUTED
{
rtems_rfs_buffer_close (*fs);
free (*fs);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
errno = rc;
ffc25d30: 93 c3 00 00 stw r30,0(r3) <== NOT EXECUTED
return -1;
ffc25d34: 38 60 ff ff li r3,-1 <== NOT EXECUTED
}
errno = 0;
return 0;
}
ffc25d38: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc25d3c: 83 41 00 50 lwz r26,80(r1) <== NOT EXECUTED
ffc25d40: 83 61 00 54 lwz r27,84(r1) <== NOT EXECUTED
ffc25d44: 83 81 00 58 lwz r28,88(r1) <== NOT EXECUTED
ffc25d48: 83 a1 00 5c lwz r29,92(r1) <== NOT EXECUTED
ffc25d4c: 83 c1 00 60 lwz r30,96(r1) <== NOT EXECUTED
ffc25d50: 83 e1 00 64 lwz r31,100(r1) <== NOT EXECUTED
ffc25d54: 38 21 00 68 addi r1,r1,104 <== NOT EXECUTED
ffc25d58: 4e 80 00 20 blr <== NOT EXECUTED
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))
ffc25d5c: 7f 89 58 40 cmplw cr7,r9,r11
ffc25d60: 40 bd ff 08 ble- cr7,ffc25c68 <rtems_rfs_fs_open+0x324> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc25d64: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc25d68: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc25d6c: 4b ff 1b fd bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc25d70: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc25d74: 41 9e fd bc beq+ cr7,ffc25b30 <rtems_rfs_fs_open+0x1ec> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block/size count\n");
ffc25d78: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc25d7c: 38 63 d7 e4 addi r3,r3,-10268 <== NOT EXECUTED
ffc25d80: 48 00 51 79 bl ffc2aef8 <puts> <== NOT EXECUTED
ffc25d84: 4b ff fd ac b ffc25b30 <rtems_rfs_fs_open+0x1ec> <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
ffc25d88: 89 1d 00 10 lbz r8,16(r29)
fs->inodes = fs->group_count * fs->group_inodes;
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
if (fs->group_blocks >
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
ffc25d8c: 54 05 18 38 rlwinm r5,r0,3,0,28
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
ffc25d90: 89 7d 00 11 lbz r11,17(r29)
ffc25d94: 89 5d 00 13 lbz r10,19(r29)
ffc25d98: 55 08 c0 0e rlwinm r8,r8,24,0,7
ffc25d9c: 89 3d 00 12 lbz r9,18(r29)
ffc25da0: 55 6b 80 1e rlwinm r11,r11,16,0,15
ffc25da4: 7d 0b 5b 78 or r11,r8,r11
ffc25da8: 7d 6b 53 78 or r11,r11,r10
ffc25dac: 55 29 40 2e rlwinm r9,r9,8,0,23
ffc25db0: 7d 69 4b 78 or r9,r11,r9
ffc25db4: 91 3e 00 14 stw r9,20(r30)
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
ffc25db8: 54 09 f0 be rlwinm r9,r0,30,2,31
fs->block_map_doubly_blocks =
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->inodes = fs->group_count * fs->group_inodes;
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
ffc25dbc: 54 00 e8 fe rlwinm r0,r0,29,3,31
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
ffc25dc0: 88 fd 00 14 lbz r7,20(r29)
ffc25dc4: 89 5d 00 15 lbz r10,21(r29)
ffc25dc8: 89 1d 00 17 lbz r8,23(r29)
ffc25dcc: 54 e7 c0 0e rlwinm r7,r7,24,0,7
ffc25dd0: 89 7d 00 16 lbz r11,22(r29)
ffc25dd4: 55 4a 80 1e rlwinm r10,r10,16,0,15
ffc25dd8: 7c ea 53 78 or r10,r7,r10
ffc25ddc: 7d 4a 43 78 or r10,r10,r8
ffc25de0: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc25de4: 7d 4b 5b 78 or r11,r10,r11
ffc25de8: 91 7e 00 18 stw r11,24(r30)
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
ffc25dec: 88 fd 00 18 lbz r7,24(r29)
ffc25df0: 89 5d 00 19 lbz r10,25(r29)
ffc25df4: 89 1d 00 1b lbz r8,27(r29)
ffc25df8: 54 e7 c0 0e rlwinm r7,r7,24,0,7
ffc25dfc: 89 7d 00 1a lbz r11,26(r29)
ffc25e00: 55 4a 80 1e rlwinm r10,r10,16,0,15
ffc25e04: 7c ea 53 78 or r10,r7,r10
ffc25e08: 7d 4a 43 78 or r10,r10,r8
ffc25e0c: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc25e10: 7d 4a 5b 78 or r10,r10,r11
ffc25e14: 91 5e 00 20 stw r10,32(r30)
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->block_map_doubly_blocks =
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
ffc25e18: 7c e9 49 d6 mullw r7,r9,r9
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
ffc25e1c: 88 9d 00 1c lbz r4,28(r29)
ffc25e20: 89 1d 00 1d lbz r8,29(r29)
ffc25e24: 88 dd 00 1f lbz r6,31(r29)
ffc25e28: 54 84 c0 0e rlwinm r4,r4,24,0,7
ffc25e2c: 89 7d 00 1e lbz r11,30(r29)
ffc25e30: 55 08 80 1e rlwinm r8,r8,16,0,15
ffc25e34: 7c 88 43 78 or r8,r4,r8
ffc25e38: 7d 08 33 78 or r8,r8,r6
ffc25e3c: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc25e40: 7d 08 5b 78 or r8,r8,r11
ffc25e44: 91 1e 00 24 stw r8,36(r30)
fs->inodes = fs->group_count * fs->group_inodes;
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
if (fs->group_blocks >
ffc25e48: 7f 88 28 40 cmplw cr7,r8,r5
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
ffc25e4c: 88 7d 00 20 lbz r3,32(r29)
ffc25e50: 88 dd 00 21 lbz r6,33(r29)
ffc25e54: 88 9d 00 23 lbz r4,35(r29)
ffc25e58: 54 63 c0 0e rlwinm r3,r3,24,0,7
ffc25e5c: 89 7d 00 22 lbz r11,34(r29)
ffc25e60: 54 c6 80 1e rlwinm r6,r6,16,0,15
ffc25e64: 7c 66 33 78 or r6,r3,r6
fs->blocks_per_block =
ffc25e68: 91 3e 00 30 stw r9,48(r30)
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
ffc25e6c: 7c c6 23 78 or r6,r6,r4
ffc25e70: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc25e74: 7c cb 5b 78 or r11,r6,r11
fs->block_map_singly_blocks =
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->block_map_doubly_blocks =
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->inodes = fs->group_count * fs->group_inodes;
ffc25e78: 7d 4b 51 d6 mullw r10,r11,r10
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
ffc25e7c: 91 7e 00 28 stw r11,40(r30)
fs->block_map_doubly_blocks =
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->inodes = fs->group_count * fs->group_inodes;
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
ffc25e80: 3d 60 24 92 lis r11,9362
ffc25e84: 61 6b 49 25 ori r11,r11,18725
fs->block_map_singly_blocks =
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->block_map_doubly_blocks =
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->inodes = fs->group_count * fs->group_inodes;
ffc25e88: 91 5e 00 10 stw r10,16(r30)
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
ffc25e8c: 7c 00 58 16 mulhwu r0,r0,r11
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
ffc25e90: 1d 29 00 05 mulli r9,r9,5
fs->block_map_doubly_blocks =
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->inodes = fs->group_count * fs->group_inodes;
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
ffc25e94: 90 1e 00 2c stw r0,44(r30)
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->block_map_doubly_blocks =
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
ffc25e98: 1d 67 00 05 mulli r11,r7,5
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
ffc25e9c: 91 3e 00 34 stw r9,52(r30)
ffc25ea0: 38 81 00 08 addi r4,r1,8
ffc25ea4: 7f c3 f3 78 mr r3,r30
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->block_map_doubly_blocks =
ffc25ea8: 91 7e 00 38 stw r11,56(r30)
fs->inodes = fs->group_count * fs->group_inodes;
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
if (fs->group_blocks >
ffc25eac: 40 9d 00 44 ble- cr7,ffc25ef0 <rtems_rfs_fs_open+0x5ac> <== ALWAYS TAKEN
ffc25eb0: 4b ff c7 91 bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
ffc25eb4: 38 00 00 00 li r0,0 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc25eb8: 39 20 00 00 li r9,0 <== NOT EXECUTED
handle->bnum = 0;
ffc25ebc: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc25ec0: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc25ec4: 38 80 00 01 li r4,1 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc25ec8: 99 21 00 08 stb r9,8(r1) <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
return EIO;
ffc25ecc: 3b 60 00 05 li r27,5 <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
ffc25ed0: 90 01 00 10 stw r0,16(r1) <== NOT EXECUTED
if (fs->group_blocks >
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc25ed4: 4b ff 1a 95 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc25ed8: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc25edc: 41 9e fb ac beq+ cr7,ffc25a88 <rtems_rfs_fs_open+0x144> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
ffc25ee0: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc25ee4: 38 63 d8 68 addi r3,r3,-10136 <== NOT EXECUTED
ffc25ee8: 48 00 50 11 bl ffc2aef8 <puts> <== NOT EXECUTED
ffc25eec: 4b ff fb 9c b ffc25a88 <rtems_rfs_fs_open+0x144> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc25ef0: 4b ff c7 51 bl ffc22640 <rtems_rfs_buffer_handle_release>
rtems_rfs_buffer_handle_close (fs, &handle);
/*
* Change the block size to the value in the superblock.
*/
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_block_size (fs));
ffc25ef4: 80 9e 00 08 lwz r4,8(r30)
handle->dirty = false;
handle->bnum = 0;
ffc25ef8: 3b a0 00 00 li r29,0
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc25efc: 38 00 00 00 li r0,0
handle->bnum = 0;
ffc25f00: 93 a1 00 0c stw r29,12(r1)
ffc25f04: 7f c3 f3 78 mr r3,r30
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc25f08: 98 01 00 08 stb r0,8(r1)
handle->bnum = 0;
handle->buffer = NULL;
ffc25f0c: 93 a1 00 10 stw r29,16(r1)
ffc25f10: 4b ff cf 81 bl ffc22e90 <rtems_rfs_buffer_setblksize>
if (rc > 0)
ffc25f14: 7c 7b 1b 79 mr. r27,r3
ffc25f18: 40 81 00 88 ble- ffc25fa0 <rtems_rfs_fs_open+0x65c> <== ALWAYS TAKEN
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc25f1c: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc25f20: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc25f24: 4b ff c7 1d bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc25f28: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc25f2c: 38 80 00 01 li r4,1 <== NOT EXECUTED
handle->dirty = false;
ffc25f30: 9b a1 00 08 stb r29,8(r1) <== NOT EXECUTED
handle->bnum = 0;
ffc25f34: 93 a1 00 0c stw r29,12(r1) <== NOT EXECUTED
handle->buffer = NULL;
ffc25f38: 93 a1 00 10 stw r29,16(r1) <== NOT EXECUTED
ffc25f3c: 4b ff 1a 2d bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc25f40: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc25f44: 41 9e fb 44 beq+ cr7,ffc25a88 <rtems_rfs_fs_open+0x144> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
ffc25f48: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc25f4c: 48 00 5b 65 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc25f50: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc25f54: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc25f58: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc25f5c: 38 63 d8 ac addi r3,r3,-10068 <== NOT EXECUTED
ffc25f60: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc25f64: 48 00 4d e1 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc25f68: 4b ff fb 20 b ffc25a88 <rtems_rfs_fs_open+0x144> <== NOT EXECUTED
printf ("rtems-rfs: open: %s\n", name);
*fs = malloc (sizeof (rtems_rfs_file_system));
if (!*fs)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc25f6c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc25f70: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc25f74: 4b ff 19 f5 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc25f78: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc25f7c: 41 be 00 10 beq+ cr7,ffc25f8c <rtems_rfs_fs_open+0x648> <== NOT EXECUTED
printf ("rtems-rfs: open: no memory for file system data\n");
ffc25f80: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc25f84: 38 63 d7 14 addi r3,r3,-10476 <== NOT EXECUTED
ffc25f88: 48 00 4f 71 bl ffc2aef8 <puts> <== NOT EXECUTED
errno = ENOMEM;
ffc25f8c: 48 00 3c d5 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc25f90: 38 00 00 0c li r0,12 <== NOT EXECUTED
ffc25f94: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
return -1;
ffc25f98: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc25f9c: 4b ff fb 1c b ffc25ab8 <rtems_rfs_fs_open+0x174> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
rc, strerror (rc));
return rc;
}
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
ffc25fa0: 83 be 00 20 lwz r29,32(r30)
ffc25fa4: 38 80 00 50 li r4,80
ffc25fa8: 7f a3 eb 78 mr r3,r29
ffc25fac: 4b fe 1e 85 bl ffc07e30 <calloc>
if (!fs->groups)
ffc25fb0: 2f 83 00 00 cmpwi cr7,r3,0
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
rc, strerror (rc));
return rc;
}
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
ffc25fb4: 90 7e 00 1c stw r3,28(r30)
ffc25fb8: 7c 67 1b 78 mr r7,r3
if (!fs->groups)
ffc25fbc: 41 9e 02 5c beq- cr7,ffc26218 <rtems_rfs_fs_open+0x8d4> <== NEVER TAKEN
/*
* Perform each phase of group initialisation at the same time. This way we
* know how far the initialisation has gone if an error occurs and we need to
* close everything.
*/
for (group = 0; group < fs->group_count; group++)
ffc25fc0: 2f 9d 00 00 cmpwi cr7,r29,0
ffc25fc4: 40 9d 00 d8 ble- cr7,ffc2609c <rtems_rfs_fs_open+0x758> <== NEVER TAKEN
if (!fs->groups)
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: no memory for group table\n");
ffc25fc8: 80 be 00 24 lwz r5,36(r30)
/*
* Perform each phase of group initialisation at the same time. This way we
* know how far the initialisation has gone if an error occurs and we need to
* close everything.
*/
for (group = 0; group < fs->group_count; group++)
ffc25fcc: 3b 80 00 00 li r28,0
ffc25fd0: 3b a0 00 00 li r29,0
ffc25fd4: 48 00 00 1c b ffc25ff0 <rtems_rfs_fs_open+0x6ac>
ffc25fd8: 80 1e 00 20 lwz r0,32(r30)
ffc25fdc: 3b bd 00 01 addi r29,r29,1
ffc25fe0: 7f 9d 00 00 cmpw cr7,r29,r0
ffc25fe4: 40 9c 00 b8 bge- cr7,ffc2609c <rtems_rfs_fs_open+0x758> <== ALWAYS TAKEN
ffc25fe8: 80 be 00 24 lwz r5,36(r30) <== NOT EXECUTED
ffc25fec: 80 fe 00 1c lwz r7,28(r30) <== NOT EXECUTED
{
rc = rtems_rfs_group_open (fs,
rtems_rfs_fs_block (fs, group, 0),
ffc25ff0: 7c 9d 29 d6 mullw r4,r29,r5
* know how far the initialisation has gone if an error occurs and we need to
* close everything.
*/
for (group = 0; group < fs->group_count; group++)
{
rc = rtems_rfs_group_open (fs,
ffc25ff4: 80 de 00 28 lwz r6,40(r30)
ffc25ff8: 7c e7 e2 14 add r7,r7,r28
ffc25ffc: 7f c3 f3 78 mr r3,r30
ffc26000: 38 84 00 01 addi r4,r4,1
ffc26004: 4b fe d5 01 bl ffc13504 <rtems_rfs_group_open>
/*
* Perform each phase of group initialisation at the same time. This way we
* know how far the initialisation has gone if an error occurs and we need to
* close everything.
*/
for (group = 0; group < fs->group_count; group++)
ffc26008: 3b 9c 00 50 addi r28,r28,80
rc = rtems_rfs_group_open (fs,
rtems_rfs_fs_block (fs, group, 0),
fs->group_blocks,
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
ffc2600c: 7c 7b 1b 79 mr. r27,r3
ffc26010: 40 81 ff c8 ble+ ffc25fd8 <rtems_rfs_fs_open+0x694> <== ALWAYS TAKEN
{
int g;
for (g = 0; g < group; g++)
ffc26014: 2f 9d 00 00 cmpwi cr7,r29,0 <== NOT EXECUTED
ffc26018: 41 9e 00 2c beq- cr7,ffc26044 <rtems_rfs_fs_open+0x700> <== NOT EXECUTED
ffc2601c: 3b 40 00 00 li r26,0 <== NOT EXECUTED
ffc26020: 3b 80 00 00 li r28,0 <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
ffc26024: 80 9e 00 1c lwz r4,28(r30) <== NOT EXECUTED
ffc26028: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
{
int g;
for (g = 0; g < group; g++)
ffc2602c: 3b 9c 00 01 addi r28,r28,1 <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
ffc26030: 7c 84 d2 14 add r4,r4,r26 <== NOT EXECUTED
ffc26034: 4b fe d7 99 bl ffc137cc <rtems_rfs_group_close> <== NOT EXECUTED
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
{
int g;
for (g = 0; g < group; g++)
ffc26038: 7f 9c e8 00 cmpw cr7,r28,r29 <== NOT EXECUTED
ffc2603c: 3b 5a 00 50 addi r26,r26,80 <== NOT EXECUTED
ffc26040: 40 9e ff e4 bne+ cr7,ffc26024 <rtems_rfs_fs_open+0x6e0> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc26044: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc26048: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc2604c: 4b ff c5 f5 bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
ffc26050: 38 00 00 00 li r0,0 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc26054: 39 20 00 00 li r9,0 <== NOT EXECUTED
handle->bnum = 0;
ffc26058: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc2605c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc26060: 38 80 00 01 li r4,1 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc26064: 99 21 00 08 stb r9,8(r1) <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
ffc26068: 90 01 00 10 stw r0,16(r1) <== NOT EXECUTED
ffc2606c: 4b ff 18 fd bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc26070: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc26074: 41 9e fa 14 beq+ cr7,ffc25a88 <rtems_rfs_fs_open+0x144> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table%d: %s\n",
ffc26078: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc2607c: 48 00 5a 35 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc26080: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc26084: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc26088: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc2608c: 38 63 d9 28 addi r3,r3,-9944 <== NOT EXECUTED
ffc26090: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc26094: 48 00 4c b1 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc26098: 4b ff f9 f0 b ffc25a88 <rtems_rfs_fs_open+0x144> <== NOT EXECUTED
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
ffc2609c: 80 7f 00 00 lwz r3,0(r31)
ffc260a0: 38 80 00 01 li r4,1
ffc260a4: 38 a1 00 14 addi r5,r1,20
ffc260a8: 38 c0 00 01 li r6,1
ffc260ac: 4b fe df 2d bl ffc13fd8 <rtems_rfs_inode_open>
if (rc > 0)
ffc260b0: 7c 7e 1b 79 mr. r30,r3
ffc260b4: 41 81 01 1c bgt- ffc261d0 <rtems_rfs_fs_open+0x88c> <== NEVER TAKEN
rc, strerror (rc));
errno = rc;
return -1;
}
if (((*fs)->flags & RTEMS_RFS_FS_FORCE_OPEN) == 0)
ffc260b8: 80 7f 00 00 lwz r3,0(r31)
ffc260bc: 80 03 00 00 lwz r0,0(r3)
ffc260c0: 70 09 00 04 andi. r9,r0,4
ffc260c4: 40 82 00 30 bne- ffc260f4 <rtems_rfs_fs_open+0x7b0>
{
mode = rtems_rfs_inode_get_mode (&inode);
ffc260c8: 81 21 00 20 lwz r9,32(r1)
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
ffc260cc: 88 09 00 02 lbz r0,2(r9)
ffc260d0: 89 29 00 03 lbz r9,3(r9)
ffc260d4: 54 00 40 2e rlwinm r0,r0,8,0,23
ffc260d8: 7c 00 4b 78 or r0,r0,r9
if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))
ffc260dc: 6c 09 ff ff xoris r9,r0,65535
ffc260e0: 2f 89 ff ff cmpwi cr7,r9,-1
ffc260e4: 41 9e 00 a0 beq- cr7,ffc26184 <rtems_rfs_fs_open+0x840> <== NEVER TAKEN
ffc260e8: 54 00 04 26 rlwinm r0,r0,0,16,19
ffc260ec: 2f 80 40 00 cmpwi cr7,r0,16384
ffc260f0: 40 9e 00 94 bne- cr7,ffc26184 <rtems_rfs_fs_open+0x840> <== NEVER TAKEN
errno = EIO;
return -1;
}
}
rc = rtems_rfs_inode_close (*fs, &inode);
ffc260f4: 38 81 00 14 addi r4,r1,20
ffc260f8: 4b fe e1 41 bl ffc14238 <rtems_rfs_inode_close>
if (rc > 0)
ffc260fc: 7c 7e 1b 79 mr. r30,r3
ffc26100: 41 81 00 3c bgt- ffc2613c <rtems_rfs_fs_open+0x7f8> <== NEVER TAKEN
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
errno = rc;
return -1;
}
errno = 0;
ffc26104: 48 00 3b 5d bl ffc29c60 <__errno>
ffc26108: 38 00 00 00 li r0,0
ffc2610c: 90 03 00 00 stw r0,0(r3)
return 0;
ffc26110: 38 60 00 00 li r3,0
}
ffc26114: 80 01 00 6c lwz r0,108(r1)
ffc26118: 83 41 00 50 lwz r26,80(r1)
ffc2611c: 7c 08 03 a6 mtlr r0
ffc26120: 83 61 00 54 lwz r27,84(r1)
ffc26124: 83 81 00 58 lwz r28,88(r1)
ffc26128: 83 a1 00 5c lwz r29,92(r1)
ffc2612c: 83 c1 00 60 lwz r30,96(r1)
ffc26130: 83 e1 00 64 lwz r31,100(r1)
ffc26134: 38 21 00 68 addi r1,r1,104
ffc26138: 4e 80 00 20 blr
}
rc = rtems_rfs_inode_close (*fs, &inode);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
ffc2613c: 80 7f 00 00 lwz r3,0(r31) <== NOT EXECUTED
ffc26140: 4b ff ce a5 bl ffc22fe4 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
ffc26144: 80 7f 00 00 lwz r3,0(r31) <== NOT EXECUTED
ffc26148: 4b fe 23 99 bl ffc084e0 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc2614c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc26150: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc26154: 4b ff 18 15 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc26158: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc2615c: 41 9e fb cc beq+ cr7,ffc25d28 <rtems_rfs_fs_open+0x3e4> <== NOT EXECUTED
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
ffc26160: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc26164: 48 00 59 4d bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc26168: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc2616c: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc26170: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc26174: 38 63 d9 f4 addi r3,r3,-9740 <== NOT EXECUTED
ffc26178: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc2617c: 48 00 4b c9 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc26180: 4b ff fb a8 b ffc25d28 <rtems_rfs_fs_open+0x3e4> <== NOT EXECUTED
{
mode = rtems_rfs_inode_get_mode (&inode);
if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))
{
rtems_rfs_inode_close (*fs, &inode);
ffc26184: 38 81 00 14 addi r4,r1,20 <== NOT EXECUTED
ffc26188: 4b fe e0 b1 bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
ffc2618c: 80 7f 00 00 lwz r3,0(r31) <== NOT EXECUTED
ffc26190: 4b ff ce 55 bl ffc22fe4 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
ffc26194: 80 7f 00 00 lwz r3,0(r31) <== NOT EXECUTED
ffc26198: 4b fe 23 49 bl ffc084e0 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc2619c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc261a0: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc261a4: 4b ff 17 c5 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc261a8: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc261ac: 41 be 00 10 beq+ cr7,ffc261bc <rtems_rfs_fs_open+0x878> <== NOT EXECUTED
printf ("rtems-rfs: open: invalid root inode mode\n");
ffc261b0: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc261b4: 38 63 d9 c8 addi r3,r3,-9784 <== NOT EXECUTED
ffc261b8: 48 00 4d 41 bl ffc2aef8 <puts> <== NOT EXECUTED
errno = EIO;
ffc261bc: 48 00 3a a5 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc261c0: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc261c4: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
return -1;
ffc261c8: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc261cc: 4b ff f8 ec b ffc25ab8 <rtems_rfs_fs_open+0x174> <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
ffc261d0: 80 7f 00 00 lwz r3,0(r31) <== NOT EXECUTED
ffc261d4: 4b ff ce 11 bl ffc22fe4 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
ffc261d8: 80 7f 00 00 lwz r3,0(r31) <== NOT EXECUTED
ffc261dc: 4b fe 23 05 bl ffc084e0 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc261e0: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc261e4: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc261e8: 4b ff 17 81 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc261ec: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc261f0: 41 9e fb 38 beq+ cr7,ffc25d28 <rtems_rfs_fs_open+0x3e4> <== NOT EXECUTED
printf ("rtems-rfs: open: reading root inode: %d: %s\n",
ffc261f4: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc261f8: 48 00 58 b9 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc261fc: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc26200: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc26204: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc26208: 38 63 d9 98 addi r3,r3,-9832 <== NOT EXECUTED
ffc2620c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc26210: 48 00 4b 35 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc26214: 4b ff fb 14 b ffc25d28 <rtems_rfs_fs_open+0x3e4> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc26218: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc2621c: 90 e1 00 48 stw r7,72(r1) <== NOT EXECUTED
ffc26220: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc26224: 4b ff c4 1d bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
ffc26228: 80 e1 00 48 lwz r7,72(r1) <== NOT EXECUTED
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
if (!fs->groups)
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc2622c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc26230: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc26234: 98 e1 00 08 stb r7,8(r1) <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table\n");
return ENOMEM;
ffc26238: 3b 60 00 0c li r27,12 <== NOT EXECUTED
handle->bnum = 0;
ffc2623c: 90 e1 00 0c stw r7,12(r1) <== NOT EXECUTED
handle->buffer = NULL;
ffc26240: 90 e1 00 10 stw r7,16(r1) <== NOT EXECUTED
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
if (!fs->groups)
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc26244: 4b ff 17 25 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc26248: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc2624c: 41 9e f8 3c beq+ cr7,ffc25a88 <rtems_rfs_fs_open+0x144> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table\n");
ffc26250: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc26254: 38 63 d8 f0 addi r3,r3,-10000 <== NOT EXECUTED
ffc26258: 48 00 4c a1 bl ffc2aef8 <puts> <== NOT EXECUTED
ffc2625c: 4b ff f8 2c b ffc25a88 <rtems_rfs_fs_open+0x144> <== NOT EXECUTED
ffc25918 <rtems_rfs_fs_size>:
#include <rtems/rfs/rtems-rfs-trace.h>
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
ffc25918: 80 03 00 04 lwz r0,4(r3) <== NOT EXECUTED
uint64_t block_size = rtems_rfs_fs_block_size (fs);
ffc2591c: 81 23 00 08 lwz r9,8(r3) <== NOT EXECUTED
return blocks * block_size;
ffc25920: 7c 69 00 16 mulhwu r3,r9,r0 <== NOT EXECUTED
ffc25924: 7c 89 01 d6 mullw r4,r9,r0 <== NOT EXECUTED
}
ffc25928: 4e 80 00 20 blr <== NOT EXECUTED
ffc138e4 <rtems_rfs_group_bitmap_alloc>:
int
rtems_rfs_group_bitmap_alloc (rtems_rfs_file_system* fs,
rtems_rfs_bitmap_bit goal,
bool inode,
rtems_rfs_bitmap_bit* result)
{
ffc138e4: 7d 80 00 26 mfcr r12
rtems_rfs_bitmap_bit bit;
int offset;
bool updown;
int direction;
if (inode)
ffc138e8: 2e 05 00 00 cmpwi cr4,r5,0
int
rtems_rfs_group_bitmap_alloc (rtems_rfs_file_system* fs,
rtems_rfs_bitmap_bit goal,
bool inode,
rtems_rfs_bitmap_bit* result)
{
ffc138ec: 94 21 ff b0 stwu r1,-80(r1)
ffc138f0: 7c 08 02 a6 mflr r0
ffc138f4: 92 a1 00 24 stw r21,36(r1)
ffc138f8: 7c d5 33 78 mr r21,r6
ffc138fc: 93 81 00 40 stw r28,64(r1)
ffc13900: 7c 7c 1b 78 mr r28,r3
ffc13904: 90 01 00 54 stw r0,84(r1)
ffc13908: 92 81 00 20 stw r20,32(r1)
ffc1390c: 92 c1 00 28 stw r22,40(r1)
ffc13910: 92 e1 00 2c stw r23,44(r1)
ffc13914: 93 01 00 30 stw r24,48(r1)
ffc13918: 93 21 00 34 stw r25,52(r1)
ffc1391c: 93 41 00 38 stw r26,56(r1)
ffc13920: 93 61 00 3c stw r27,60(r1)
ffc13924: 93 a1 00 44 stw r29,68(r1)
ffc13928: 93 c1 00 48 stw r30,72(r1)
ffc1392c: 93 e1 00 4c stw r31,76(r1)
ffc13930: 91 81 00 1c stw r12,28(r1)
rtems_rfs_bitmap_bit bit;
int offset;
bool updown;
int direction;
if (inode)
ffc13934: 41 92 01 e8 beq- cr4,ffc13b1c <rtems_rfs_group_bitmap_alloc+0x238>
{
size = fs->group_inodes;
ffc13938: 83 03 00 28 lwz r24,40(r3)
goal -= RTEMS_RFS_ROOT_INO;
ffc1393c: 38 84 ff ff addi r4,r4,-1
}
else
size = fs->group_blocks;
group_start = goal / size;
ffc13940: 7f 44 c3 96 divwu r26,r4,r24
bit = (rtems_rfs_bitmap_bit) (goal % size);
ffc13944: 7c 1a c1 d6 mullw r0,r26,r24
/*
* We can start at any location and we move out from that point in each
* direction. The offset grows until we find a free bit or we hit an end.
*/
group = group_start + (direction * offset);
ffc13948: 7f 5f d3 78 mr r31,r26
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
ffc1394c: 7c 80 20 50 subf r4,r0,r4
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
ffc13950: 38 00 00 00 li r0,0
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
ffc13954: 90 81 00 0c stw r4,12(r1)
offset = 0;
updown = true;
direction = 1;
ffc13958: 3b c0 00 01 li r30,1
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
ffc1395c: 98 01 00 08 stb r0,8(r1)
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
offset = 0;
updown = true;
ffc13960: 3b 60 00 01 li r27,1
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
offset = 0;
ffc13964: 3b a0 00 00 li r29,0
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
ffc13968: 3a c0 00 00 li r22,0
/*
* If we are still looking up and down and if the group is out of range we
* have reached one end. Stopping looking up and down and just move in the
* one direction one group at a time.
*/
if ((group < 0) || (group >= fs->group_count))
ffc1396c: 2f 9f 00 00 cmpwi cr7,r31,0
ffc13970: 41 9c 00 94 blt- cr7,ffc13a04 <rtems_rfs_group_bitmap_alloc+0x120><== NEVER TAKEN
ffc13974: 80 1c 00 20 lwz r0,32(r28)
ffc13978: 7f 80 f8 00 cmpw cr7,r0,r31
ffc1397c: 40 9d 00 88 ble- cr7,ffc13a04 <rtems_rfs_group_bitmap_alloc+0x120><== NEVER TAKEN
updown = false;
continue;
}
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
ffc13980: 1e ff 00 50 mulli r23,r31,80
ffc13984: 83 3c 00 1c lwz r25,28(r28)
ffc13988: 7f 39 ba 14 add r25,r25,r23
direction = direction > 0 ? -1 : 1;
updown = false;
continue;
}
if (inode)
ffc1398c: 41 92 01 88 beq- cr4,ffc13b14 <rtems_rfs_group_bitmap_alloc+0x230>
bitmap = &fs->groups[group].inode_bitmap;
ffc13990: 3b 39 00 2c addi r25,r25,44
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
ffc13994: 80 81 00 0c lwz r4,12(r1)
ffc13998: 7f 23 cb 78 mr r3,r25
ffc1399c: 38 a1 00 08 addi r5,r1,8
ffc139a0: 38 c1 00 0c addi r6,r1,12
ffc139a4: 48 00 d3 5d bl ffc20d00 <rtems_rfs_bitmap_map_alloc>
if (rc > 0)
ffc139a8: 7c 74 1b 79 mr. r20,r3
ffc139ac: 41 81 00 f4 bgt- ffc13aa0 <rtems_rfs_group_bitmap_alloc+0x1bc><== NEVER TAKEN
return rc;
if (rtems_rfs_fs_release_bitmaps (fs))
ffc139b0: 80 1c 00 00 lwz r0,0(r28)
ffc139b4: 70 09 00 01 andi. r9,r0,1
ffc139b8: 41 82 01 6c beq- ffc13b24 <rtems_rfs_group_bitmap_alloc+0x240><== ALWAYS TAKEN
rtems_rfs_bitmap_release_buffer (fs, bitmap);
if (allocated)
ffc139bc: 88 01 00 08 lbz r0,8(r1)
ffc139c0: 2f 80 00 00 cmpwi cr7,r0,0
ffc139c4: 40 9e 00 88 bne- cr7,ffc13a4c <rtems_rfs_group_bitmap_alloc+0x168><== ALWAYS TAKEN
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
inode ? "inode" : "block", *result);
return 0;
}
if (updown)
ffc139c8: 2f 9b 00 00 cmpwi cr7,r27,0 <== NOT EXECUTED
ffc139cc: 41 9e 00 14 beq- cr7,ffc139e0 <rtems_rfs_group_bitmap_alloc+0xfc><== NOT EXECUTED
direction = direction > 0 ? -1 : 1;
ffc139d0: 6b de 00 01 xori r30,r30,1 <== NOT EXECUTED
ffc139d4: 33 de ff ff addic r30,r30,-1 <== NOT EXECUTED
ffc139d8: 7f de f1 10 subfe r30,r30,r30 <== NOT EXECUTED
ffc139dc: 63 de 00 01 ori r30,r30,1 <== NOT EXECUTED
* We can start at any location and we move out from that point in each
* direction. The offset grows until we find a free bit or we hit an end.
*/
group = group_start + (direction * offset);
if (offset)
bit = direction > 0 ? 0 : size - 1;
ffc139e0: 2f 9e 00 01 cmpwi cr7,r30,1 <== NOT EXECUTED
}
if (updown)
direction = direction > 0 ? -1 : 1;
offset++;
ffc139e4: 3b bd 00 01 addi r29,r29,1 <== NOT EXECUTED
/*
* We can start at any location and we move out from that point in each
* direction. The offset grows until we find a free bit or we hit an end.
*/
group = group_start + (direction * offset);
ffc139e8: 7f fe e9 d6 mullw r31,r30,r29 <== NOT EXECUTED
if (offset)
bit = direction > 0 ? 0 : size - 1;
ffc139ec: 38 00 00 00 li r0,0 <== NOT EXECUTED
/*
* We can start at any location and we move out from that point in each
* direction. The offset grows until we find a free bit or we hit an end.
*/
group = group_start + (direction * offset);
ffc139f0: 7f ff d2 14 add r31,r31,r26 <== NOT EXECUTED
if (offset)
bit = direction > 0 ? 0 : size - 1;
ffc139f4: 40 9e 00 4c bne- cr7,ffc13a40 <rtems_rfs_group_bitmap_alloc+0x15c><== NOT EXECUTED
ffc139f8: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
/*
* If we are still looking up and down and if the group is out of range we
* have reached one end. Stopping looking up and down and just move in the
* one direction one group at a time.
*/
if ((group < 0) || (group >= fs->group_count))
ffc139fc: 2f 9f 00 00 cmpwi cr7,r31,0 <== NOT EXECUTED
ffc13a00: 40 9c ff 74 bge+ cr7,ffc13974 <rtems_rfs_group_bitmap_alloc+0x90><== NOT EXECUTED
{
if (!updown)
ffc13a04: 2f 9b 00 00 cmpwi cr7,r27,0 <== NOT EXECUTED
ffc13a08: 41 9e 00 e4 beq- cr7,ffc13aec <rtems_rfs_group_bitmap_alloc+0x208><== NOT EXECUTED
break;
direction = direction > 0 ? -1 : 1;
ffc13a0c: 6b de 00 01 xori r30,r30,1 <== NOT EXECUTED
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
ffc13a10: 9a c1 00 08 stb r22,8(r1) <== NOT EXECUTED
*/
if ((group < 0) || (group >= fs->group_count))
{
if (!updown)
break;
direction = direction > 0 ? -1 : 1;
ffc13a14: 33 de ff ff addic r30,r30,-1 <== NOT EXECUTED
ffc13a18: 7f de f1 10 subfe r30,r30,r30 <== NOT EXECUTED
/*
* We can start at any location and we move out from that point in each
* direction. The offset grows until we find a free bit or we hit an end.
*/
group = group_start + (direction * offset);
if (offset)
ffc13a1c: 2f 9d 00 00 cmpwi cr7,r29,0 <== NOT EXECUTED
*/
if ((group < 0) || (group >= fs->group_count))
{
if (!updown)
break;
direction = direction > 0 ? -1 : 1;
ffc13a20: 63 de 00 01 ori r30,r30,1 <== NOT EXECUTED
/*
* We can start at any location and we move out from that point in each
* direction. The offset grows until we find a free bit or we hit an end.
*/
group = group_start + (direction * offset);
ffc13a24: 7f fe e9 d6 mullw r31,r30,r29 <== NOT EXECUTED
if (offset)
ffc13a28: 3b 60 00 00 li r27,0 <== NOT EXECUTED
/*
* We can start at any location and we move out from that point in each
* direction. The offset grows until we find a free bit or we hit an end.
*/
group = group_start + (direction * offset);
ffc13a2c: 7f ff d2 14 add r31,r31,r26 <== NOT EXECUTED
if (offset)
ffc13a30: 41 9e ff 3c beq+ cr7,ffc1396c <rtems_rfs_group_bitmap_alloc+0x88><== NOT EXECUTED
bit = direction > 0 ? 0 : size - 1;
ffc13a34: 2f 9e 00 01 cmpwi cr7,r30,1 <== NOT EXECUTED
ffc13a38: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc13a3c: 41 9e ff bc beq+ cr7,ffc139f8 <rtems_rfs_group_bitmap_alloc+0x114><== NOT EXECUTED
ffc13a40: 38 18 ff ff addi r0,r24,-1 <== NOT EXECUTED
ffc13a44: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
ffc13a48: 4b ff ff b4 b ffc139fc <rtems_rfs_group_bitmap_alloc+0x118><== NOT EXECUTED
if (rtems_rfs_fs_release_bitmaps (fs))
rtems_rfs_bitmap_release_buffer (fs, bitmap);
if (allocated)
{
if (inode)
ffc13a4c: 40 92 00 e8 bne- cr4,ffc13b34 <rtems_rfs_group_bitmap_alloc+0x250>
*result = rtems_rfs_group_inode (fs, group, bit);
else
*result = rtems_rfs_group_block (&fs->groups[group], bit);
ffc13a50: 81 3c 00 1c lwz r9,28(r28)
ffc13a54: 7c 09 b8 2e lwzx r0,r9,r23
ffc13a58: 81 21 00 0c lwz r9,12(r1)
ffc13a5c: 7c 09 02 14 add r0,r9,r0
ffc13a60: 90 15 00 00 stw r0,0(r21)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
ffc13a64: 38 60 00 00 li r3,0
ffc13a68: 3c 80 00 02 lis r4,2
ffc13a6c: 48 00 3e fd bl ffc17968 <rtems_rfs_trace>
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
inode ? "inode" : "block", *result);
return 0;
ffc13a70: 3a 80 00 00 li r20,0
{
if (inode)
*result = rtems_rfs_group_inode (fs, group, bit);
else
*result = rtems_rfs_group_block (&fs->groups[group], bit);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
ffc13a74: 2f 83 00 00 cmpwi cr7,r3,0
ffc13a78: 41 9e 00 28 beq- cr7,ffc13aa0 <rtems_rfs_group_bitmap_alloc+0x1bc><== ALWAYS TAKEN
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
ffc13a7c: 40 92 00 d4 bne- cr4,ffc13b50 <rtems_rfs_group_bitmap_alloc+0x26c><== NOT EXECUTED
ffc13a80: 3c 80 ff c4 lis r4,-60 <== NOT EXECUTED
ffc13a84: 38 84 b8 70 addi r4,r4,-18320 <== NOT EXECUTED
ffc13a88: 80 b5 00 00 lwz r5,0(r21) <== NOT EXECUTED
ffc13a8c: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc13a90: 38 63 b8 78 addi r3,r3,-18312 <== NOT EXECUTED
ffc13a94: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc13a98: 48 01 72 ad bl ffc2ad44 <printf> <== NOT EXECUTED
inode ? "inode" : "block", *result);
return 0;
ffc13a9c: 3a 80 00 00 li r20,0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
return ENOSPC;
}
ffc13aa0: 80 01 00 54 lwz r0,84(r1)
ffc13aa4: 7e 83 a3 78 mr r3,r20
ffc13aa8: 81 81 00 1c lwz r12,28(r1)
ffc13aac: 7c 08 03 a6 mtlr r0
ffc13ab0: 82 81 00 20 lwz r20,32(r1)
ffc13ab4: 82 a1 00 24 lwz r21,36(r1)
ffc13ab8: 7d 80 81 20 mtcrf 8,r12
ffc13abc: 82 c1 00 28 lwz r22,40(r1)
ffc13ac0: 82 e1 00 2c lwz r23,44(r1)
ffc13ac4: 83 01 00 30 lwz r24,48(r1)
ffc13ac8: 83 21 00 34 lwz r25,52(r1)
ffc13acc: 83 41 00 38 lwz r26,56(r1)
ffc13ad0: 83 61 00 3c lwz r27,60(r1)
ffc13ad4: 83 81 00 40 lwz r28,64(r1)
ffc13ad8: 83 a1 00 44 lwz r29,68(r1)
ffc13adc: 83 c1 00 48 lwz r30,72(r1)
ffc13ae0: 83 e1 00 4c lwz r31,76(r1)
ffc13ae4: 38 21 00 50 addi r1,r1,80
ffc13ae8: 4e 80 00 20 blr
direction = direction > 0 ? -1 : 1;
offset++;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
ffc13aec: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc13af0: 3c 80 00 02 lis r4,2 <== NOT EXECUTED
ffc13af4: 48 00 3e 75 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
return ENOSPC;
ffc13af8: 3a 80 00 1c li r20,28 <== NOT EXECUTED
direction = direction > 0 ? -1 : 1;
offset++;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
ffc13afc: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc13b00: 41 9e ff a0 beq+ cr7,ffc13aa0 <rtems_rfs_group_bitmap_alloc+0x1bc><== NOT EXECUTED
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
ffc13b04: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc13b08: 38 63 b8 ac addi r3,r3,-18260 <== NOT EXECUTED
ffc13b0c: 48 01 73 ed bl ffc2aef8 <puts> <== NOT EXECUTED
ffc13b10: 4b ff ff 90 b ffc13aa0 <rtems_rfs_group_bitmap_alloc+0x1bc><== NOT EXECUTED
}
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
ffc13b14: 3b 39 00 08 addi r25,r25,8
ffc13b18: 4b ff fe 7c b ffc13994 <rtems_rfs_group_bitmap_alloc+0xb0>
{
size = fs->group_inodes;
goal -= RTEMS_RFS_ROOT_INO;
}
else
size = fs->group_blocks;
ffc13b1c: 83 03 00 24 lwz r24,36(r3)
ffc13b20: 4b ff fe 20 b ffc13940 <rtems_rfs_group_bitmap_alloc+0x5c>
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
if (rc > 0)
return rc;
if (rtems_rfs_fs_release_bitmaps (fs))
rtems_rfs_bitmap_release_buffer (fs, bitmap);
ffc13b24: 80 99 00 00 lwz r4,0(r25)
ffc13b28: 7f 83 e3 78 mr r3,r28
ffc13b2c: 48 00 eb 15 bl ffc22640 <rtems_rfs_buffer_handle_release>
ffc13b30: 4b ff fe 8c b ffc139bc <rtems_rfs_group_bitmap_alloc+0xd8>
if (allocated)
{
if (inode)
*result = rtems_rfs_group_inode (fs, group, bit);
ffc13b34: 80 1c 00 28 lwz r0,40(r28)
ffc13b38: 81 21 00 0c lwz r9,12(r1)
ffc13b3c: 7f ff 01 d6 mullw r31,r31,r0
ffc13b40: 38 09 00 01 addi r0,r9,1
ffc13b44: 7c 00 fa 14 add r0,r0,r31
ffc13b48: 90 15 00 00 stw r0,0(r21)
ffc13b4c: 4b ff ff 18 b ffc13a64 <rtems_rfs_group_bitmap_alloc+0x180>
else
*result = rtems_rfs_group_block (&fs->groups[group], bit);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
ffc13b50: 3c 80 ff c4 lis r4,-60 <== NOT EXECUTED
ffc13b54: 38 84 b8 68 addi r4,r4,-18328 <== NOT EXECUTED
ffc13b58: 4b ff ff 30 b ffc13a88 <rtems_rfs_group_bitmap_alloc+0x1a4><== NOT EXECUTED
ffc13b5c <rtems_rfs_group_bitmap_free>:
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
ffc13b5c: 94 21 ff e8 stwu r1,-24(r1)
ffc13b60: 7d 80 00 26 mfcr r12
ffc13b64: 7c 08 02 a6 mflr r0
ffc13b68: 93 a1 00 0c stw r29,12(r1)
ffc13b6c: 7c 9d 23 78 mr r29,r4
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
ffc13b70: 3c 80 00 02 lis r4,2
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
ffc13b74: 93 e1 00 14 stw r31,20(r1)
ffc13b78: 7c 7f 1b 78 mr r31,r3
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
ffc13b7c: 38 60 00 00 li r3,0
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
ffc13b80: 93 c1 00 10 stw r30,16(r1)
ffc13b84: 7c be 2b 78 mr r30,r5
ffc13b88: 2e 1d 00 00 cmpwi cr4,r29,0
ffc13b8c: 90 01 00 1c stw r0,28(r1)
ffc13b90: 91 81 00 08 stw r12,8(r1)
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
ffc13b94: 48 00 3d d5 bl ffc17968 <rtems_rfs_trace>
ffc13b98: 2f 83 00 00 cmpwi cr7,r3,0
ffc13b9c: 41 9e 00 24 beq- cr7,ffc13bc0 <rtems_rfs_group_bitmap_free+0x64><== ALWAYS TAKEN
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
ffc13ba0: 40 92 00 ec bne- cr4,ffc13c8c <rtems_rfs_group_bitmap_free+0x130><== NOT EXECUTED
ffc13ba4: 3c 80 ff c4 lis r4,-60 <== NOT EXECUTED
ffc13ba8: 38 84 b8 70 addi r4,r4,-18320 <== NOT EXECUTED
ffc13bac: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc13bb0: 38 63 b8 e0 addi r3,r3,-18208 <== NOT EXECUTED
ffc13bb4: 7f c5 f3 78 mr r5,r30 <== NOT EXECUTED
ffc13bb8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc13bbc: 48 01 71 89 bl ffc2ad44 <printf> <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
ffc13bc0: 41 92 00 68 beq- cr4,ffc13c28 <rtems_rfs_group_bitmap_free+0xcc><== NEVER TAKEN
{
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
ffc13bc4: 80 9f 00 28 lwz r4,40(r31)
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
inode ? "inode" : "block", no);
if (inode)
{
no -= RTEMS_RFS_ROOT_INO;
ffc13bc8: 3b de ff ff addi r30,r30,-1
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
ffc13bcc: 83 bf 00 1c lwz r29,28(r31)
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
ffc13bd0: 7c 1e 23 96 divwu r0,r30,r4
ffc13bd4: 7c 80 21 d6 mullw r4,r0,r4
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
ffc13bd8: 1c 00 00 50 mulli r0,r0,80
ffc13bdc: 7f bd 02 14 add r29,r29,r0
ffc13be0: 3b bd 00 2c addi r29,r29,44
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
ffc13be4: 7c 84 f0 50 subf r4,r4,r30
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
ffc13be8: 7f a3 eb 78 mr r3,r29
ffc13bec: 48 00 cd f9 bl ffc209e4 <rtems_rfs_bitmap_map_clear>
rtems_rfs_bitmap_release_buffer (fs, bitmap);
ffc13bf0: 80 9d 00 00 lwz r4,0(r29)
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
ffc13bf4: 7c 7e 1b 78 mr r30,r3
rtems_rfs_bitmap_release_buffer (fs, bitmap);
ffc13bf8: 7f e3 fb 78 mr r3,r31
ffc13bfc: 48 00 ea 45 bl ffc22640 <rtems_rfs_buffer_handle_release>
return rc;
}
ffc13c00: 80 01 00 1c lwz r0,28(r1)
ffc13c04: 81 81 00 08 lwz r12,8(r1)
ffc13c08: 7f c3 f3 78 mr r3,r30
ffc13c0c: 7c 08 03 a6 mtlr r0
ffc13c10: 83 a1 00 0c lwz r29,12(r1)
ffc13c14: 83 c1 00 10 lwz r30,16(r1)
ffc13c18: 7d 80 81 20 mtcrf 8,r12
ffc13c1c: 83 e1 00 14 lwz r31,20(r1)
ffc13c20: 38 21 00 18 addi r1,r1,24
ffc13c24: 4e 80 00 20 blr
size = fs->group_inodes;
}
else
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
ffc13c28: 80 9f 00 24 lwz r4,36(r31) <== NOT EXECUTED
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
}
else
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
ffc13c2c: 3b de ff ff addi r30,r30,-1 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
ffc13c30: 83 bf 00 1c lwz r29,28(r31) <== NOT EXECUTED
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
ffc13c34: 7c 1e 23 96 divwu r0,r30,r4 <== NOT EXECUTED
ffc13c38: 7c 80 21 d6 mullw r4,r0,r4 <== NOT EXECUTED
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
ffc13c3c: 1c 00 00 50 mulli r0,r0,80 <== NOT EXECUTED
ffc13c40: 7f bd 02 14 add r29,r29,r0 <== NOT EXECUTED
ffc13c44: 3b bd 00 08 addi r29,r29,8 <== NOT EXECUTED
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
ffc13c48: 7c 84 f0 50 subf r4,r4,r30 <== NOT EXECUTED
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
ffc13c4c: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc13c50: 48 00 cd 95 bl ffc209e4 <rtems_rfs_bitmap_map_clear> <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
ffc13c54: 80 9d 00 00 lwz r4,0(r29) <== NOT EXECUTED
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
ffc13c58: 7c 7e 1b 78 mr r30,r3 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
ffc13c5c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc13c60: 48 00 e9 e1 bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
return rc;
}
ffc13c64: 80 01 00 1c lwz r0,28(r1) <== NOT EXECUTED
ffc13c68: 81 81 00 08 lwz r12,8(r1) <== NOT EXECUTED
ffc13c6c: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc13c70: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc13c74: 83 a1 00 0c lwz r29,12(r1) <== NOT EXECUTED
ffc13c78: 83 c1 00 10 lwz r30,16(r1) <== NOT EXECUTED
ffc13c7c: 7d 80 81 20 mtcrf 8,r12 <== NOT EXECUTED
ffc13c80: 83 e1 00 14 lwz r31,20(r1) <== NOT EXECUTED
ffc13c84: 38 21 00 18 addi r1,r1,24 <== NOT EXECUTED
ffc13c88: 4e 80 00 20 blr <== NOT EXECUTED
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
ffc13c8c: 3c 80 ff c4 lis r4,-60 <== NOT EXECUTED
ffc13c90: 38 84 b8 68 addi r4,r4,-18328 <== NOT EXECUTED
ffc13c94: 4b ff ff 18 b ffc13bac <rtems_rfs_group_bitmap_free+0x50><== NOT EXECUTED
ffc13c98 <rtems_rfs_group_bitmap_test>:
int
rtems_rfs_group_bitmap_test (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no,
bool* state)
{
ffc13c98: 94 21 ff e0 stwu r1,-32(r1) <== NOT EXECUTED
ffc13c9c: 7d 80 00 26 mfcr r12 <== NOT EXECUTED
ffc13ca0: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc13ca4: 93 a1 00 14 stw r29,20(r1) <== NOT EXECUTED
ffc13ca8: 7c 9d 23 78 mr r29,r4 <== NOT EXECUTED
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
ffc13cac: 3c 80 00 02 lis r4,2 <== NOT EXECUTED
int
rtems_rfs_group_bitmap_test (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no,
bool* state)
{
ffc13cb0: 93 c1 00 18 stw r30,24(r1) <== NOT EXECUTED
ffc13cb4: 7c 7e 1b 78 mr r30,r3 <== NOT EXECUTED
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
ffc13cb8: 38 60 00 00 li r3,0 <== NOT EXECUTED
int
rtems_rfs_group_bitmap_test (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no,
bool* state)
{
ffc13cbc: 93 81 00 10 stw r28,16(r1) <== NOT EXECUTED
ffc13cc0: 7c dc 33 78 mr r28,r6 <== NOT EXECUTED
ffc13cc4: 2e 1d 00 00 cmpwi cr4,r29,0 <== NOT EXECUTED
ffc13cc8: 93 e1 00 1c stw r31,28(r1) <== NOT EXECUTED
ffc13ccc: 7c bf 2b 78 mr r31,r5 <== NOT EXECUTED
ffc13cd0: 90 01 00 24 stw r0,36(r1) <== NOT EXECUTED
ffc13cd4: 93 61 00 0c stw r27,12(r1) <== NOT EXECUTED
ffc13cd8: 91 81 00 08 stw r12,8(r1) <== NOT EXECUTED
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
ffc13cdc: 48 00 3c 8d bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc13ce0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc13ce4: 41 9e 00 24 beq- cr7,ffc13d08 <rtems_rfs_group_bitmap_test+0x70><== NOT EXECUTED
printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",
ffc13ce8: 40 92 00 e8 bne- cr4,ffc13dd0 <rtems_rfs_group_bitmap_test+0x138><== NOT EXECUTED
ffc13cec: 3c 80 ff c4 lis r4,-60 <== NOT EXECUTED
ffc13cf0: 38 84 b8 70 addi r4,r4,-18320 <== NOT EXECUTED
ffc13cf4: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc13cf8: 38 63 b9 0c addi r3,r3,-18164 <== NOT EXECUTED
ffc13cfc: 7f e5 fb 78 mr r5,r31 <== NOT EXECUTED
ffc13d00: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc13d04: 48 01 70 41 bl ffc2ad44 <printf> <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
ffc13d08: 41 92 00 4c beq- cr4,ffc13d54 <rtems_rfs_group_bitmap_test+0xbc><== NOT EXECUTED
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
ffc13d0c: 2f 9f 00 00 cmpwi cr7,r31,0 <== NOT EXECUTED
return EINVAL;
ffc13d10: 3b 60 00 16 li r27,22 <== NOT EXECUTED
printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",
inode ? "inode" : "block", no);
if (inode)
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
ffc13d14: 40 9d 00 10 ble- cr7,ffc13d24 <rtems_rfs_group_bitmap_test+0x8c><== NOT EXECUTED
ffc13d18: 80 1e 00 10 lwz r0,16(r30) <== NOT EXECUTED
ffc13d1c: 7f 9f 00 40 cmplw cr7,r31,r0 <== NOT EXECUTED
ffc13d20: 40 9d 00 bc ble- cr7,ffc13ddc <rtems_rfs_group_bitmap_test+0x144><== NOT EXECUTED
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
rtems_rfs_bitmap_release_buffer (fs, bitmap);
return rc;
}
ffc13d24: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
ffc13d28: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc13d2c: 81 81 00 08 lwz r12,8(r1) <== NOT EXECUTED
ffc13d30: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc13d34: 83 61 00 0c lwz r27,12(r1) <== NOT EXECUTED
ffc13d38: 83 81 00 10 lwz r28,16(r1) <== NOT EXECUTED
ffc13d3c: 7d 80 81 20 mtcrf 8,r12 <== NOT EXECUTED
ffc13d40: 83 a1 00 14 lwz r29,20(r1) <== NOT EXECUTED
ffc13d44: 83 c1 00 18 lwz r30,24(r1) <== NOT EXECUTED
ffc13d48: 83 e1 00 1c lwz r31,28(r1) <== NOT EXECUTED
ffc13d4c: 38 21 00 20 addi r1,r1,32 <== NOT EXECUTED
ffc13d50: 4e 80 00 20 blr <== NOT EXECUTED
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
}
else
{
if (no >= rtems_rfs_fs_blocks (fs))
ffc13d54: 80 1e 00 04 lwz r0,4(r30) <== NOT EXECUTED
return EINVAL;
ffc13d58: 3b 60 00 16 li r27,22 <== NOT EXECUTED
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
}
else
{
if (no >= rtems_rfs_fs_blocks (fs))
ffc13d5c: 7f 9f 00 40 cmplw cr7,r31,r0 <== NOT EXECUTED
ffc13d60: 40 9c ff c4 bge+ cr7,ffc13d24 <rtems_rfs_group_bitmap_test+0x8c><== NOT EXECUTED
return EINVAL;
size = fs->group_blocks;
ffc13d64: 80 9e 00 24 lwz r4,36(r30) <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
ffc13d68: 83 be 00 1c lwz r29,28(r30) <== NOT EXECUTED
return EINVAL;
size = fs->group_blocks;
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
ffc13d6c: 7c 1f 23 96 divwu r0,r31,r4 <== NOT EXECUTED
ffc13d70: 7c 80 21 d6 mullw r4,r0,r4 <== NOT EXECUTED
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
ffc13d74: 1c 00 00 50 mulli r0,r0,80 <== NOT EXECUTED
ffc13d78: 7f bd 02 14 add r29,r29,r0 <== NOT EXECUTED
return EINVAL;
size = fs->group_blocks;
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
ffc13d7c: 7c 84 f8 50 subf r4,r4,r31 <== NOT EXECUTED
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
ffc13d80: 3b bd 00 08 addi r29,r29,8 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
ffc13d84: 7f 85 e3 78 mr r5,r28 <== NOT EXECUTED
ffc13d88: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc13d8c: 48 00 cd 21 bl ffc20aac <rtems_rfs_bitmap_map_test> <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
ffc13d90: 80 9d 00 00 lwz r4,0(r29) <== NOT EXECUTED
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
ffc13d94: 7c 7b 1b 78 mr r27,r3 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
ffc13d98: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc13d9c: 48 00 e8 a5 bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
return rc;
}
ffc13da0: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
ffc13da4: 81 81 00 08 lwz r12,8(r1) <== NOT EXECUTED
ffc13da8: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc13dac: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc13db0: 83 61 00 0c lwz r27,12(r1) <== NOT EXECUTED
ffc13db4: 83 81 00 10 lwz r28,16(r1) <== NOT EXECUTED
ffc13db8: 7d 80 81 20 mtcrf 8,r12 <== NOT EXECUTED
ffc13dbc: 83 a1 00 14 lwz r29,20(r1) <== NOT EXECUTED
ffc13dc0: 83 c1 00 18 lwz r30,24(r1) <== NOT EXECUTED
ffc13dc4: 83 e1 00 1c lwz r31,28(r1) <== NOT EXECUTED
ffc13dc8: 38 21 00 20 addi r1,r1,32 <== NOT EXECUTED
ffc13dcc: 4e 80 00 20 blr <== NOT EXECUTED
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",
ffc13dd0: 3c 80 ff c4 lis r4,-60 <== NOT EXECUTED
ffc13dd4: 38 84 b8 68 addi r4,r4,-18328 <== NOT EXECUTED
ffc13dd8: 4b ff ff 1c b ffc13cf4 <rtems_rfs_group_bitmap_test+0x5c><== NOT EXECUTED
if (inode)
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
return EINVAL;
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
ffc13ddc: 80 9e 00 28 lwz r4,40(r30) <== NOT EXECUTED
if (inode)
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
return EINVAL;
no -= RTEMS_RFS_ROOT_INO;
ffc13de0: 3b ff ff ff addi r31,r31,-1 <== NOT EXECUTED
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
ffc13de4: 83 be 00 1c lwz r29,28(r30) <== NOT EXECUTED
return EINVAL;
size = fs->group_blocks;
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
ffc13de8: 7c 1f 23 96 divwu r0,r31,r4 <== NOT EXECUTED
ffc13dec: 7c 80 21 d6 mullw r4,r0,r4 <== NOT EXECUTED
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
ffc13df0: 1c 00 00 50 mulli r0,r0,80 <== NOT EXECUTED
ffc13df4: 7f bd 02 14 add r29,r29,r0 <== NOT EXECUTED
return EINVAL;
size = fs->group_blocks;
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
ffc13df8: 7c 84 f8 50 subf r4,r4,r31 <== NOT EXECUTED
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
ffc13dfc: 3b bd 00 2c addi r29,r29,44 <== NOT EXECUTED
ffc13e00: 4b ff ff 84 b ffc13d84 <rtems_rfs_group_bitmap_test+0xec><== NOT EXECUTED
ffc137cc <rtems_rfs_group_close>:
return 0;
}
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
ffc137cc: 94 21 ff e8 stwu r1,-24(r1)
ffc137d0: 7c 08 02 a6 mflr r0
ffc137d4: 93 c1 00 10 stw r30,16(r1)
ffc137d8: 7c 7e 1b 78 mr r30,r3
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
ffc137dc: 38 60 00 00 li r3,0
return 0;
}
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
ffc137e0: 93 e1 00 14 stw r31,20(r1)
ffc137e4: 7c 9f 23 78 mr r31,r4
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
ffc137e8: 3c 80 00 01 lis r4,1
return 0;
}
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
ffc137ec: 90 01 00 1c stw r0,28(r1)
ffc137f0: 93 81 00 08 stw r28,8(r1)
ffc137f4: 93 a1 00 0c stw r29,12(r1)
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
ffc137f8: 48 00 41 71 bl ffc17968 <rtems_rfs_trace>
ffc137fc: 2f 83 00 00 cmpwi cr7,r3,0
ffc13800: 40 9e 00 84 bne- cr7,ffc13884 <rtems_rfs_group_close+0xb8><== NEVER TAKEN
/*
* We need to close as much as possible and also return any error if one
* occurs but this may result in one even more important error being lost but
* we cannot OR the errors together so this is a reasonable compromise.
*/
rc = rtems_rfs_bitmap_close (&group->inode_bitmap);
ffc13804: 38 7f 00 2c addi r3,r31,44
ffc13808: 48 00 d7 b1 bl ffc20fb8 <rtems_rfs_bitmap_close>
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc1380c: 38 9f 00 44 addi r4,r31,68
ffc13810: 7c 7c 1b 78 mr r28,r3
ffc13814: 7f c3 f3 78 mr r3,r30
ffc13818: 48 00 ee 29 bl ffc22640 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
handle->bnum = 0;
ffc1381c: 38 00 00 00 li r0,0
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc13820: 39 20 00 00 li r9,0
handle->bnum = 0;
ffc13824: 90 1f 00 48 stw r0,72(r31)
if (rc > 0)
result = rc;
rc = rtems_rfs_buffer_handle_close (fs, &group->inode_bitmap_buffer);
if (rc > 0)
result = rc;
rc = rtems_rfs_bitmap_close (&group->block_bitmap);
ffc13828: 38 7f 00 08 addi r3,r31,8
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc1382c: 99 3f 00 44 stb r9,68(r31)
handle->bnum = 0;
handle->buffer = NULL;
ffc13830: 90 1f 00 4c stw r0,76(r31)
ffc13834: 48 00 d7 85 bl ffc20fb8 <rtems_rfs_bitmap_close>
if (rc > 0)
ffc13838: 7c 7d 1b 79 mr. r29,r3
ffc1383c: 40 81 00 98 ble- ffc138d4 <rtems_rfs_group_close+0x108> <== ALWAYS TAKEN
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc13840: 7f c3 f3 78 mr r3,r30
ffc13844: 38 9f 00 20 addi r4,r31,32
ffc13848: 48 00 ed f9 bl ffc22640 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
handle->bnum = 0;
ffc1384c: 38 00 00 00 li r0,0
ffc13850: 90 1f 00 24 stw r0,36(r31)
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc13854: 39 20 00 00 li r9,0
rc = rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rc > 0)
result = rc;
return result;
}
ffc13858: 7f a3 eb 78 mr r3,r29
handle->bnum = 0;
handle->buffer = NULL;
ffc1385c: 90 1f 00 28 stw r0,40(r31)
ffc13860: 80 01 00 1c lwz r0,28(r1)
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc13864: 99 3f 00 20 stb r9,32(r31)
ffc13868: 7c 08 03 a6 mtlr r0
ffc1386c: 83 81 00 08 lwz r28,8(r1)
ffc13870: 83 a1 00 0c lwz r29,12(r1)
ffc13874: 83 c1 00 10 lwz r30,16(r1)
ffc13878: 83 e1 00 14 lwz r31,20(r1)
ffc1387c: 38 21 00 18 addi r1,r1,24
ffc13880: 4e 80 00 20 blr
{
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
printf ("rtems-rfs: group-close: base=%" PRId32 "\n", group->base);
ffc13884: 80 9f 00 00 lwz r4,0(r31) <== NOT EXECUTED
ffc13888: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc1388c: 38 63 b8 44 addi r3,r3,-18364 <== NOT EXECUTED
ffc13890: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc13894: 48 01 74 b1 bl ffc2ad44 <printf> <== NOT EXECUTED
/*
* We need to close as much as possible and also return any error if one
* occurs but this may result in one even more important error being lost but
* we cannot OR the errors together so this is a reasonable compromise.
*/
rc = rtems_rfs_bitmap_close (&group->inode_bitmap);
ffc13898: 38 7f 00 2c addi r3,r31,44 <== NOT EXECUTED
ffc1389c: 48 00 d7 1d bl ffc20fb8 <rtems_rfs_bitmap_close> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc138a0: 38 9f 00 44 addi r4,r31,68 <== NOT EXECUTED
ffc138a4: 7c 7c 1b 78 mr r28,r3 <== NOT EXECUTED
ffc138a8: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc138ac: 48 00 ed 95 bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
ffc138b0: 38 00 00 00 li r0,0 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc138b4: 39 20 00 00 li r9,0 <== NOT EXECUTED
handle->bnum = 0;
ffc138b8: 90 1f 00 48 stw r0,72(r31) <== NOT EXECUTED
if (rc > 0)
result = rc;
rc = rtems_rfs_buffer_handle_close (fs, &group->inode_bitmap_buffer);
if (rc > 0)
result = rc;
rc = rtems_rfs_bitmap_close (&group->block_bitmap);
ffc138bc: 38 7f 00 08 addi r3,r31,8 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
ffc138c0: 99 3f 00 44 stb r9,68(r31) <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
ffc138c4: 90 1f 00 4c stw r0,76(r31) <== NOT EXECUTED
ffc138c8: 48 00 d6 f1 bl ffc20fb8 <rtems_rfs_bitmap_close> <== NOT EXECUTED
if (rc > 0)
ffc138cc: 7c 7d 1b 79 mr. r29,r3 <== NOT EXECUTED
ffc138d0: 41 81 ff 70 bgt+ ffc13840 <rtems_rfs_group_close+0x74> <== NOT EXECUTED
ffc138d4: 7f 9d e0 f8 not r29,r28
ffc138d8: 7f bd fe 70 srawi r29,r29,31
ffc138dc: 7f 9d e8 38 and r29,r28,r29
ffc138e0: 4b ff ff 60 b ffc13840 <rtems_rfs_group_close+0x74>
ffc13504 <rtems_rfs_group_open>:
rtems_rfs_group_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_block base,
size_t size,
size_t inodes,
rtems_rfs_group* group)
{
ffc13504: 94 21 ff d8 stwu r1,-40(r1)
ffc13508: 7c 08 02 a6 mflr r0
ffc1350c: 90 01 00 2c stw r0,44(r1)
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
ffc13510: 80 03 00 04 lwz r0,4(r3)
rtems_rfs_group_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_block base,
size_t size,
size_t inodes,
rtems_rfs_group* group)
{
ffc13514: 93 61 00 14 stw r27,20(r1)
ffc13518: 7c 7b 1b 78 mr r27,r3
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
ffc1351c: 7f 80 20 40 cmplw cr7,r0,r4
rtems_rfs_group_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_block base,
size_t size,
size_t inodes,
rtems_rfs_group* group)
{
ffc13520: 93 81 00 18 stw r28,24(r1)
ffc13524: 7c 9c 23 78 mr r28,r4
ffc13528: 93 c1 00 20 stw r30,32(r1)
ffc1352c: 7c be 2b 78 mr r30,r5
ffc13530: 93 e1 00 24 stw r31,36(r1)
ffc13534: 7c ff 3b 78 mr r31,r7
ffc13538: 93 01 00 08 stw r24,8(r1)
ffc1353c: 93 21 00 0c stw r25,12(r1)
ffc13540: 93 41 00 10 stw r26,16(r1)
ffc13544: 93 a1 00 1c stw r29,28(r1)
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
ffc13548: 40 9d 01 1c ble- cr7,ffc13664 <rtems_rfs_group_open+0x160><== NEVER TAKEN
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
EIO, strerror (EIO));
return EIO;
}
if ((base + size) >= rtems_rfs_fs_blocks (fs))
ffc1354c: 7d 25 22 14 add r9,r5,r4
ffc13550: 7f 80 48 40 cmplw cr7,r0,r9
ffc13554: 41 9d 00 08 bgt- cr7,ffc1355c <rtems_rfs_group_open+0x58><== NEVER TAKEN
size = rtems_rfs_fs_blocks (fs) - base;
ffc13558: 7f c4 00 50 subf r30,r4,r0
ffc1355c: 7f 9e 30 40 cmplw cr7,r30,r6
ffc13560: 7f d8 f3 78 mr r24,r30
ffc13564: 41 9d 00 c4 bgt- cr7,ffc13628 <rtems_rfs_group_open+0x124><== ALWAYS TAKEN
* the format configuration needs reviewing.
*/
if (inodes > size)
inodes = size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
ffc13568: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc1356c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc13570: 60 84 80 00 ori r4,r4,32768 <== NOT EXECUTED
ffc13574: 48 00 43 f5 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc13578: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1357c: 40 9e 00 c8 bne- cr7,ffc13644 <rtems_rfs_group_open+0x140><== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
handle->bnum = 0;
ffc13580: 3b a0 00 00 li r29,0
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
base, size, inodes);
group->base = base;
ffc13584: 93 9f 00 00 stw r28,0(r31)
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc13588: 38 00 00 00 li r0,0
printf ("rtems-rfs: group-open: could not open block bitmap handle: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_bitmap_open (&group->block_bitmap, fs,
ffc1358c: 3b 3f 00 08 addi r25,r31,8
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
base, size, inodes);
group->base = base;
group->size = size;
ffc13590: 93 df 00 04 stw r30,4(r31)
printf ("rtems-rfs: group-open: could not open block bitmap handle: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_bitmap_open (&group->block_bitmap, fs,
ffc13594: 3b 5f 00 20 addi r26,r31,32
ffc13598: 98 1f 00 20 stb r0,32(r31)
ffc1359c: 7f 87 e3 78 mr r7,r28
ffc135a0: 7f 23 cb 78 mr r3,r25
handle->bnum = 0;
ffc135a4: 93 bf 00 24 stw r29,36(r31)
ffc135a8: 7f 64 db 78 mr r4,r27
ffc135ac: 7f 45 d3 78 mr r5,r26
handle->buffer = NULL;
ffc135b0: 93 bf 00 28 stw r29,40(r31)
ffc135b4: 7f c6 f3 78 mr r6,r30
ffc135b8: 48 00 d9 91 bl ffc20f48 <rtems_rfs_bitmap_open>
&group->block_bitmap_buffer, size,
group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
ffc135bc: 7c 7c 1b 79 mr. r28,r3
ffc135c0: 40 81 01 38 ble- ffc136f8 <rtems_rfs_group_open+0x1f4> <== ALWAYS TAKEN
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc135c4: 7f 44 d3 78 mr r4,r26 <== NOT EXECUTED
ffc135c8: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc135cc: 48 00 f0 75 bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
ffc135d0: 9b bf 00 20 stb r29,32(r31) <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
ffc135d4: 38 80 00 00 li r4,0 <== NOT EXECUTED
handle->bnum = 0;
ffc135d8: 93 bf 00 24 stw r29,36(r31) <== NOT EXECUTED
ffc135dc: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc135e0: 60 84 80 00 ori r4,r4,32768 <== NOT EXECUTED
handle->buffer = NULL;
ffc135e4: 93 bf 00 28 stw r29,40(r31) <== NOT EXECUTED
ffc135e8: 48 00 43 81 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc135ec: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc135f0: 40 9e 00 b4 bne- cr7,ffc136a4 <rtems_rfs_group_open+0x1a0><== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
}
return 0;
}
ffc135f4: 80 01 00 2c lwz r0,44(r1)
ffc135f8: 7f 83 e3 78 mr r3,r28
ffc135fc: 83 01 00 08 lwz r24,8(r1)
ffc13600: 7c 08 03 a6 mtlr r0
ffc13604: 83 21 00 0c lwz r25,12(r1)
ffc13608: 83 41 00 10 lwz r26,16(r1)
ffc1360c: 83 61 00 14 lwz r27,20(r1)
ffc13610: 83 81 00 18 lwz r28,24(r1)
ffc13614: 83 a1 00 1c lwz r29,28(r1)
ffc13618: 83 c1 00 20 lwz r30,32(r1)
ffc1361c: 83 e1 00 24 lwz r31,36(r1)
ffc13620: 38 21 00 28 addi r1,r1,40
ffc13624: 4e 80 00 20 blr
* the format configuration needs reviewing.
*/
if (inodes > size)
inodes = size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
ffc13628: 38 80 00 00 li r4,0
ffc1362c: 38 60 00 00 li r3,0
ffc13630: 60 84 80 00 ori r4,r4,32768
EIO, strerror (EIO));
return EIO;
}
if ((base + size) >= rtems_rfs_fs_blocks (fs))
size = rtems_rfs_fs_blocks (fs) - base;
ffc13634: 7c d8 33 78 mr r24,r6
* the format configuration needs reviewing.
*/
if (inodes > size)
inodes = size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
ffc13638: 48 00 43 31 bl ffc17968 <rtems_rfs_trace>
ffc1363c: 2f 83 00 00 cmpwi cr7,r3,0
ffc13640: 41 9e ff 40 beq+ cr7,ffc13580 <rtems_rfs_group_open+0x7c><== ALWAYS TAKEN
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
ffc13644: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc13648: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc1364c: 7f c5 f3 78 mr r5,r30 <== NOT EXECUTED
ffc13650: 7f 06 c3 78 mr r6,r24 <== NOT EXECUTED
ffc13654: 38 63 b7 94 addi r3,r3,-18540 <== NOT EXECUTED
ffc13658: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1365c: 48 01 76 e9 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc13660: 4b ff ff 20 b ffc13580 <rtems_rfs_group_open+0x7c> <== NOT EXECUTED
{
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
ffc13664: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc13668: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1366c: 60 84 80 00 ori r4,r4,32768 <== NOT EXECUTED
ffc13670: 48 00 42 f9 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
EIO, strerror (EIO));
return EIO;
ffc13674: 3b 80 00 05 li r28,5 <== NOT EXECUTED
{
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
ffc13678: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1367c: 41 9e ff 78 beq+ cr7,ffc135f4 <rtems_rfs_group_open+0xf0><== NOT EXECUTED
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
ffc13680: 38 60 00 05 li r3,5 <== NOT EXECUTED
ffc13684: 48 01 84 2d bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc13688: 38 80 00 05 li r4,5 <== NOT EXECUTED
ffc1368c: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc13690: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc13694: 38 63 b7 54 addi r3,r3,-18604 <== NOT EXECUTED
ffc13698: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1369c: 48 01 76 a9 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc136a0: 4b ff ff 54 b ffc135f4 <rtems_rfs_group_open+0xf0> <== NOT EXECUTED
group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
printf ("rtems-rfs: group-open: could not open block bitmap: %d: %s\n",
ffc136a4: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc136a8: 48 01 84 09 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc136ac: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc136b0: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc136b4: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc136b8: 38 63 b7 cc addi r3,r3,-18484 <== NOT EXECUTED
ffc136bc: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc136c0: 48 01 76 85 bl ffc2ad44 <printf> <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
}
return 0;
}
ffc136c4: 80 01 00 2c lwz r0,44(r1) <== NOT EXECUTED
ffc136c8: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc136cc: 83 01 00 08 lwz r24,8(r1) <== NOT EXECUTED
ffc136d0: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc136d4: 83 21 00 0c lwz r25,12(r1) <== NOT EXECUTED
ffc136d8: 83 41 00 10 lwz r26,16(r1) <== NOT EXECUTED
ffc136dc: 83 61 00 14 lwz r27,20(r1) <== NOT EXECUTED
ffc136e0: 83 81 00 18 lwz r28,24(r1) <== NOT EXECUTED
ffc136e4: 83 a1 00 1c lwz r29,28(r1) <== NOT EXECUTED
ffc136e8: 83 c1 00 20 lwz r30,32(r1) <== NOT EXECUTED
ffc136ec: 83 e1 00 24 lwz r31,36(r1) <== NOT EXECUTED
ffc136f0: 38 21 00 28 addi r1,r1,40 <== NOT EXECUTED
ffc136f4: 4e 80 00 20 blr <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open inode bitmap handle: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_bitmap_open (&group->inode_bitmap, fs,
ffc136f8: 80 ff 00 00 lwz r7,0(r31)
ffc136fc: 3b df 00 44 addi r30,r31,68
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc13700: 9b bf 00 44 stb r29,68(r31)
ffc13704: 38 7f 00 2c addi r3,r31,44
ffc13708: 7f 64 db 78 mr r4,r27
handle->bnum = 0;
ffc1370c: 93 bf 00 48 stw r29,72(r31)
ffc13710: 7f c5 f3 78 mr r5,r30
ffc13714: 7f 06 c3 78 mr r6,r24
handle->buffer = NULL;
ffc13718: 93 bf 00 4c stw r29,76(r31)
ffc1371c: 38 e7 00 01 addi r7,r7,1
ffc13720: 48 00 d8 29 bl ffc20f48 <rtems_rfs_bitmap_open>
&group->inode_bitmap_buffer, inodes,
group->base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
ffc13724: 7c 7c 1b 79 mr. r28,r3
ffc13728: 40 81 00 78 ble- ffc137a0 <rtems_rfs_group_open+0x29c> <== ALWAYS TAKEN
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc1372c: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc13730: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc13734: 48 00 ef 0d bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
ffc13738: 9b bf 00 44 stb r29,68(r31) <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &group->inode_bitmap_buffer);
rtems_rfs_bitmap_close (&group->block_bitmap);
ffc1373c: 7f 23 cb 78 mr r3,r25 <== NOT EXECUTED
handle->bnum = 0;
ffc13740: 93 bf 00 48 stw r29,72(r31) <== NOT EXECUTED
handle->buffer = NULL;
ffc13744: 93 bf 00 4c stw r29,76(r31) <== NOT EXECUTED
ffc13748: 48 00 d8 71 bl ffc20fb8 <rtems_rfs_bitmap_close> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc1374c: 7f 44 d3 78 mr r4,r26 <== NOT EXECUTED
ffc13750: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc13754: 48 00 ee ed bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
ffc13758: 9b bf 00 20 stb r29,32(r31) <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
ffc1375c: 38 80 00 00 li r4,0 <== NOT EXECUTED
handle->bnum = 0;
ffc13760: 93 bf 00 24 stw r29,36(r31) <== NOT EXECUTED
ffc13764: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc13768: 60 84 80 00 ori r4,r4,32768 <== NOT EXECUTED
handle->buffer = NULL;
ffc1376c: 93 bf 00 28 stw r29,40(r31) <== NOT EXECUTED
ffc13770: 48 00 41 f9 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc13774: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc13778: 41 9e fe 7c beq+ cr7,ffc135f4 <rtems_rfs_group_open+0xf0><== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open inode bitmap: %d: %s\n",
ffc1377c: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc13780: 48 01 83 31 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc13784: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc13788: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc1378c: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc13790: 38 63 b8 08 addi r3,r3,-18424 <== NOT EXECUTED
ffc13794: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc13798: 48 01 75 ad bl ffc2ad44 <printf> <== NOT EXECUTED
ffc1379c: 4b ff fe 58 b ffc135f4 <rtems_rfs_group_open+0xf0> <== NOT EXECUTED
rc, strerror (rc));
return rc;
}
if (rtems_rfs_fs_release_bitmaps (fs))
ffc137a0: 80 1b 00 00 lwz r0,0(r27)
{
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
}
return 0;
ffc137a4: 3b 80 00 00 li r28,0
printf ("rtems-rfs: group-open: could not open inode bitmap: %d: %s\n",
rc, strerror (rc));
return rc;
}
if (rtems_rfs_fs_release_bitmaps (fs))
ffc137a8: 70 09 00 01 andi. r9,r0,1
ffc137ac: 40 82 fe 48 bne+ ffc135f4 <rtems_rfs_group_open+0xf0> <== NEVER TAKEN
{
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
ffc137b0: 80 9f 00 08 lwz r4,8(r31)
ffc137b4: 7f 63 db 78 mr r3,r27
ffc137b8: 48 00 ee 89 bl ffc22640 <rtems_rfs_buffer_handle_release>
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
ffc137bc: 80 9f 00 2c lwz r4,44(r31)
ffc137c0: 7f 63 db 78 mr r3,r27
ffc137c4: 48 00 ee 7d bl ffc22640 <rtems_rfs_buffer_handle_release>
ffc137c8: 4b ff fe 2c b ffc135f4 <rtems_rfs_group_open+0xf0>
ffc13e04 <rtems_rfs_group_usage>:
size_t* blocks,
size_t* inodes)
{
int g;
*blocks = 0;
ffc13e04: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc13e08: 90 04 00 00 stw r0,0(r4) <== NOT EXECUTED
*inodes = 0;
ffc13e0c: 90 05 00 00 stw r0,0(r5) <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
ffc13e10: 80 03 00 20 lwz r0,32(r3) <== NOT EXECUTED
ffc13e14: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc13e18: 40 9d 00 50 ble- cr7,ffc13e68 <rtems_rfs_group_usage+0x64><== NOT EXECUTED
ffc13e1c: 81 23 00 1c lwz r9,28(r3) <== NOT EXECUTED
ffc13e20: 39 60 00 00 li r11,0 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
ffc13e24: 81 09 00 14 lwz r8,20(r9) <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
ffc13e28: 39 6b 00 01 addi r11,r11,1 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
ffc13e2c: 80 04 00 00 lwz r0,0(r4) <== NOT EXECUTED
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
ffc13e30: 81 49 00 18 lwz r10,24(r9) <== NOT EXECUTED
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
ffc13e34: 7c 08 02 14 add r0,r8,r0 <== NOT EXECUTED
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
ffc13e38: 7c 0a 00 50 subf r0,r10,r0 <== NOT EXECUTED
ffc13e3c: 90 04 00 00 stw r0,0(r4) <== NOT EXECUTED
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
rtems_rfs_bitmap_map_free (&group->block_bitmap);
*inodes +=
rtems_rfs_bitmap_map_size (&group->inode_bitmap) -
ffc13e40: 81 09 00 38 lwz r8,56(r9) <== NOT EXECUTED
ffc13e44: 80 05 00 00 lwz r0,0(r5) <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
rtems_rfs_bitmap_map_free (&group->block_bitmap);
*inodes +=
ffc13e48: 81 49 00 3c lwz r10,60(r9) <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
ffc13e4c: 39 29 00 50 addi r9,r9,80 <== NOT EXECUTED
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
rtems_rfs_bitmap_map_free (&group->block_bitmap);
*inodes +=
rtems_rfs_bitmap_map_size (&group->inode_bitmap) -
ffc13e50: 7c 08 02 14 add r0,r8,r0 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
rtems_rfs_bitmap_map_free (&group->block_bitmap);
*inodes +=
ffc13e54: 7c 0a 00 50 subf r0,r10,r0 <== NOT EXECUTED
ffc13e58: 90 05 00 00 stw r0,0(r5) <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
ffc13e5c: 80 03 00 20 lwz r0,32(r3) <== NOT EXECUTED
ffc13e60: 7f 80 58 00 cmpw cr7,r0,r11 <== NOT EXECUTED
ffc13e64: 41 9d ff c0 bgt+ cr7,ffc13e24 <rtems_rfs_group_usage+0x20><== NOT EXECUTED
*inodes +=
rtems_rfs_bitmap_map_size (&group->inode_bitmap) -
rtems_rfs_bitmap_map_free (&group->inode_bitmap);
}
if (*blocks > rtems_rfs_fs_blocks (fs))
ffc13e68: 81 23 00 04 lwz r9,4(r3) <== NOT EXECUTED
ffc13e6c: 80 04 00 00 lwz r0,0(r4) <== NOT EXECUTED
ffc13e70: 7f 80 48 40 cmplw cr7,r0,r9 <== NOT EXECUTED
ffc13e74: 40 9d 00 08 ble- cr7,ffc13e7c <rtems_rfs_group_usage+0x78><== NOT EXECUTED
ffc13e78: 7d 20 4b 78 mr r0,r9 <== NOT EXECUTED
ffc13e7c: 90 04 00 00 stw r0,0(r4) <== NOT EXECUTED
*blocks = rtems_rfs_fs_blocks (fs);
if (*inodes > rtems_rfs_fs_inodes (fs))
ffc13e80: 81 23 00 10 lwz r9,16(r3) <== NOT EXECUTED
ffc13e84: 80 05 00 00 lwz r0,0(r5) <== NOT EXECUTED
ffc13e88: 7f 80 48 40 cmplw cr7,r0,r9 <== NOT EXECUTED
ffc13e8c: 40 9d 00 08 ble- cr7,ffc13e94 <rtems_rfs_group_usage+0x90><== NOT EXECUTED
ffc13e90: 7d 20 4b 78 mr r0,r9 <== NOT EXECUTED
ffc13e94: 90 05 00 00 stw r0,0(r5) <== NOT EXECUTED
*inodes = rtems_rfs_fs_inodes (fs);
return 0;
}
ffc13e98: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc13e9c: 4e 80 00 20 blr <== NOT EXECUTED
ffc14238 <rtems_rfs_inode_close>:
}
int
rtems_rfs_inode_close (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
ffc14238: 94 21 ff f0 stwu r1,-16(r1)
ffc1423c: 7c 08 02 a6 mflr r0
ffc14240: 93 c1 00 08 stw r30,8(r1)
ffc14244: 7c 7e 1b 78 mr r30,r3
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
ffc14248: 38 60 00 00 li r3,0
}
int
rtems_rfs_inode_close (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
ffc1424c: 93 e1 00 0c stw r31,12(r1)
ffc14250: 7c 9f 23 78 mr r31,r4
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
ffc14254: 3c 80 00 08 lis r4,8
}
int
rtems_rfs_inode_close (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
ffc14258: 90 01 00 14 stw r0,20(r1)
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
ffc1425c: 48 00 37 0d bl ffc17968 <rtems_rfs_trace>
ffc14260: 2f 83 00 00 cmpwi cr7,r3,0
ffc14264: 40 9e 00 64 bne- cr7,ffc142c8 <rtems_rfs_inode_close+0x90><== NEVER TAKEN
printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
rc = rtems_rfs_inode_unload (fs, handle, true);
ffc14268: 7f c3 f3 78 mr r3,r30
ffc1426c: 7f e4 fb 78 mr r4,r31
ffc14270: 38 a0 00 01 li r5,1
ffc14274: 4b ff fe 85 bl ffc140f8 <rtems_rfs_inode_unload>
if ((rc == 0) && (handle->loads > 0))
ffc14278: 7c 7e 1b 79 mr. r30,r3
ffc1427c: 40 82 00 28 bne- ffc142a4 <rtems_rfs_inode_close+0x6c> <== NEVER TAKEN
ffc14280: 80 1f 00 24 lwz r0,36(r31)
ffc14284: 2f 80 00 00 cmpwi cr7,r0,0
ffc14288: 40 9d 00 1c ble- cr7,ffc142a4 <rtems_rfs_inode_close+0x6c><== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
ffc1428c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc14290: 3c 80 00 08 lis r4,8 <== NOT EXECUTED
ffc14294: 48 00 36 d5 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
handle->loads);
rc = EIO;
ffc14298: 3b c0 00 05 li r30,5 <== NOT EXECUTED
rc = rtems_rfs_inode_unload (fs, handle, true);
if ((rc == 0) && (handle->loads > 0))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
ffc1429c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc142a0: 40 9e 00 40 bne- cr7,ffc142e0 <rtems_rfs_inode_close+0xa8><== NOT EXECUTED
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
handle->loads);
rc = EIO;
}
handle->ino = 0;
ffc142a4: 38 00 00 00 li r0,0
ffc142a8: 90 1f 00 08 stw r0,8(r31)
return rc;
}
ffc142ac: 7f c3 f3 78 mr r3,r30
ffc142b0: 80 01 00 14 lwz r0,20(r1)
ffc142b4: 83 c1 00 08 lwz r30,8(r1)
ffc142b8: 7c 08 03 a6 mtlr r0
ffc142bc: 83 e1 00 0c lwz r31,12(r1)
ffc142c0: 38 21 00 10 addi r1,r1,16
ffc142c4: 4e 80 00 20 blr
rtems_rfs_inode_handle* handle)
{
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
ffc142c8: 80 9f 00 08 lwz r4,8(r31) <== NOT EXECUTED
ffc142cc: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc142d0: 38 63 b9 cc addi r3,r3,-17972 <== NOT EXECUTED
ffc142d4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc142d8: 48 01 6a 6d bl ffc2ad44 <printf> <== NOT EXECUTED
ffc142dc: 4b ff ff 8c b ffc14268 <rtems_rfs_inode_close+0x30> <== NOT EXECUTED
rc = rtems_rfs_inode_unload (fs, handle, true);
if ((rc == 0) && (handle->loads > 0))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
ffc142e0: 80 9f 00 24 lwz r4,36(r31) <== NOT EXECUTED
ffc142e4: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc142e8: 38 63 b9 f0 addi r3,r3,-17936 <== NOT EXECUTED
ffc142ec: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc142f0: 48 01 6a 55 bl ffc2ad44 <printf> <== NOT EXECUTED
handle->loads);
rc = EIO;
}
handle->ino = 0;
ffc142f4: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc142f8: 90 1f 00 08 stw r0,8(r31) <== NOT EXECUTED
return rc;
}
ffc142fc: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc14300: 80 01 00 14 lwz r0,20(r1) <== NOT EXECUTED
ffc14304: 83 c1 00 08 lwz r30,8(r1) <== NOT EXECUTED
ffc14308: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc1430c: 83 e1 00 0c lwz r31,12(r1) <== NOT EXECUTED
ffc14310: 38 21 00 10 addi r1,r1,16 <== NOT EXECUTED
ffc14314: 4e 80 00 20 blr <== NOT EXECUTED
ffc1465c <rtems_rfs_inode_create>:
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
ffc1465c: 94 21 ff 70 stwu r1,-144(r1)
ffc14660: 7d 80 00 26 mfcr r12
ffc14664: 7c 08 02 a6 mflr r0
ffc14668: 93 81 00 80 stw r28,128(r1)
ffc1466c: 7c 7c 1b 78 mr r28,r3
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
ffc14670: 38 60 00 00 li r3,0
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
ffc14674: 93 a1 00 84 stw r29,132(r1)
ffc14678: 7c 9d 23 78 mr r29,r4
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
ffc1467c: 3c 80 00 40 lis r4,64
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
ffc14680: 92 c1 00 68 stw r22,104(r1)
ffc14684: 7d 56 53 78 mr r22,r10
ffc14688: 92 e1 00 6c stw r23,108(r1)
ffc1468c: 7d 37 4b 78 mr r23,r9
ffc14690: 93 01 00 70 stw r24,112(r1)
ffc14694: 93 21 00 74 stw r25,116(r1)
ffc14698: 93 41 00 78 stw r26,120(r1)
ffc1469c: 7d 1a 43 78 mr r26,r8
ffc146a0: 93 61 00 7c stw r27,124(r1)
ffc146a4: 7c fb 3b 78 mr r27,r7
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
ffc146a8: 57 79 04 26 rlwinm r25,r27,0,16,19
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
ffc146ac: 93 c1 00 88 stw r30,136(r1)
ffc146b0: 7c be 2b 78 mr r30,r5
ffc146b4: 2e 19 60 00 cmpwi cr4,r25,24576
ffc146b8: 93 e1 00 8c stw r31,140(r1)
ffc146bc: 7c df 33 78 mr r31,r6
ffc146c0: 90 01 00 94 stw r0,148(r1)
ffc146c4: 92 81 00 60 stw r20,96(r1)
ffc146c8: 92 a1 00 64 stw r21,100(r1)
ffc146cc: 91 81 00 5c stw r12,92(r1)
ffc146d0: 83 01 00 98 lwz r24,152(r1)
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
ffc146d4: 48 00 32 95 bl ffc17968 <rtems_rfs_trace>
ffc146d8: 2f 83 00 00 cmpwi cr7,r3,0
ffc146dc: 41 9e 00 94 beq- cr7,ffc14770 <rtems_rfs_inode_create+0x114><== ALWAYS TAKEN
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
ffc146e0: 2f 99 40 00 cmpwi cr7,r25,16384 <== NOT EXECUTED
ffc146e4: 41 9e 01 50 beq- cr7,ffc14834 <rtems_rfs_inode_create+0x1d8><== NOT EXECUTED
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
ffc146e8: 2f 99 20 00 cmpwi cr7,r25,8192 <== NOT EXECUTED
ffc146ec: 41 9e 01 64 beq- cr7,ffc14850 <rtems_rfs_inode_create+0x1f4><== NOT EXECUTED
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
ffc146f0: 2e 19 60 00 cmpwi cr4,r25,24576 <== NOT EXECUTED
ffc146f4: 41 92 01 50 beq- cr4,ffc14844 <rtems_rfs_inode_create+0x1e8><== NOT EXECUTED
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
ffc146f8: 6f 20 ff ff xoris r0,r25,65535 <== NOT EXECUTED
ffc146fc: 2f 80 80 00 cmpwi cr7,r0,-32768 <== NOT EXECUTED
ffc14700: 41 9e 01 60 beq- cr7,ffc14860 <rtems_rfs_inode_create+0x204><== NOT EXECUTED
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
ffc14704: 6f 20 ff ff xoris r0,r25,65535 <== NOT EXECUTED
ffc14708: 2f 80 a0 00 cmpwi cr7,r0,-24576 <== NOT EXECUTED
ffc1470c: 41 9e 01 60 beq- cr7,ffc1486c <rtems_rfs_inode_create+0x210><== NOT EXECUTED
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
{
const char* type = "unknown";
ffc14710: 3e a0 ff c4 lis r21,-60 <== NOT EXECUTED
ffc14714: 3a b5 ba 58 addi r21,r21,-17832 <== NOT EXECUTED
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
type = "link";
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
ffc14718: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc1471c: 38 63 ba 68 addi r3,r3,-17816 <== NOT EXECUTED
ffc14720: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc14724: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc14728: 48 01 66 1d bl ffc2ad44 <printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
ffc1472c: 2f 9f 00 00 cmpwi cr7,r31,0 <== NOT EXECUTED
ffc14730: 41 9e 00 24 beq- cr7,ffc14754 <rtems_rfs_inode_create+0xf8><== NOT EXECUTED
ffc14734: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc14738: 3a 80 00 00 li r20,0 <== NOT EXECUTED
printf ("%c", name[c]);
ffc1473c: 7c 7e 00 ae lbzx r3,r30,r0 <== NOT EXECUTED
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
type = "link";
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
for (c = 0; c < length; c++)
ffc14740: 3a 94 00 01 addi r20,r20,1 <== NOT EXECUTED
printf ("%c", name[c]);
ffc14744: 48 01 66 bd bl ffc2ae00 <putchar> <== NOT EXECUTED
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
type = "link";
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
for (c = 0; c < length; c++)
ffc14748: 7f 94 f8 00 cmpw cr7,r20,r31 <== NOT EXECUTED
ffc1474c: 7e 80 a3 78 mr r0,r20 <== NOT EXECUTED
ffc14750: 40 9e ff ec bne+ cr7,ffc1473c <rtems_rfs_inode_create+0xe0><== NOT EXECUTED
printf ("%c", name[c]);
printf (" type:%s mode:%04x (%03o)\n", type, mode, mode & ((1 << 10) - 1));
ffc14754: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc14758: 38 63 ba 94 addi r3,r3,-17772 <== NOT EXECUTED
ffc1475c: 7e a4 ab 78 mr r4,r21 <== NOT EXECUTED
ffc14760: 7f 65 db 78 mr r5,r27 <== NOT EXECUTED
ffc14764: 57 66 05 be clrlwi r6,r27,22 <== NOT EXECUTED
ffc14768: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1476c: 48 01 65 d9 bl ffc2ad44 <printf> <== NOT EXECUTED
}
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & RTEMS_RFS_S_IFMT)
ffc14770: 41 92 00 80 beq- cr4,ffc147f0 <rtems_rfs_inode_create+0x194><== NEVER TAKEN
ffc14774: 40 91 00 6c ble- cr4,ffc147e0 <rtems_rfs_inode_create+0x184>
ffc14778: 6f 20 ff ff xoris r0,r25,65535
ffc1477c: 2f 80 80 00 cmpwi cr7,r0,-32768
ffc14780: 41 9e 00 70 beq- cr7,ffc147f0 <rtems_rfs_inode_create+0x194>
ffc14784: 6f 20 ff ff xoris r0,r25,65535
ffc14788: 2f 80 a0 00 cmpwi cr7,r0,-24576
ffc1478c: 41 9e 00 64 beq- cr7,ffc147f0 <rtems_rfs_inode_create+0x194><== ALWAYS TAKEN
case RTEMS_RFS_S_IFBLK:
case RTEMS_RFS_S_IFREG:
case RTEMS_RFS_S_IFLNK:
break;
default:
return EINVAL;
ffc14790: 3a a0 00 16 li r21,22 <== NOT EXECUTED
rtems_rfs_inode_free (fs, *ino);
return rc;
}
return 0;
}
ffc14794: 80 01 00 94 lwz r0,148(r1)
ffc14798: 7e a3 ab 78 mr r3,r21
ffc1479c: 81 81 00 5c lwz r12,92(r1)
ffc147a0: 7c 08 03 a6 mtlr r0
ffc147a4: 82 81 00 60 lwz r20,96(r1)
ffc147a8: 82 a1 00 64 lwz r21,100(r1)
ffc147ac: 7d 80 81 20 mtcrf 8,r12
ffc147b0: 82 c1 00 68 lwz r22,104(r1)
ffc147b4: 82 e1 00 6c lwz r23,108(r1)
ffc147b8: 83 01 00 70 lwz r24,112(r1)
ffc147bc: 83 21 00 74 lwz r25,116(r1)
ffc147c0: 83 41 00 78 lwz r26,120(r1)
ffc147c4: 83 61 00 7c lwz r27,124(r1)
ffc147c8: 83 81 00 80 lwz r28,128(r1)
ffc147cc: 83 a1 00 84 lwz r29,132(r1)
ffc147d0: 83 c1 00 88 lwz r30,136(r1)
ffc147d4: 83 e1 00 8c lwz r31,140(r1)
ffc147d8: 38 21 00 90 addi r1,r1,144
ffc147dc: 4e 80 00 20 blr
}
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & RTEMS_RFS_S_IFMT)
ffc147e0: 2f 99 20 00 cmpwi cr7,r25,8192
ffc147e4: 41 9e 00 0c beq- cr7,ffc147f0 <rtems_rfs_inode_create+0x194><== NEVER TAKEN
ffc147e8: 2f 99 40 00 cmpwi cr7,r25,16384
ffc147ec: 40 9e ff a4 bne+ cr7,ffc14790 <rtems_rfs_inode_create+0x134><== NEVER TAKEN
break;
default:
return EINVAL;
}
rc = rtems_rfs_inode_alloc (fs, parent, ino);
ffc147f0: 7f 83 e3 78 mr r3,r28
ffc147f4: 7f a4 eb 78 mr r4,r29
ffc147f8: 7f 05 c3 78 mr r5,r24
ffc147fc: 4b ff f6 a5 bl ffc13ea0 <rtems_rfs_inode_alloc>
if (rc > 0)
ffc14800: 7c 75 1b 79 mr. r21,r3
ffc14804: 41 81 ff 90 bgt+ ffc14794 <rtems_rfs_inode_create+0x138><== NEVER TAKEN
return rc;
rc = rtems_rfs_inode_open (fs, *ino, &inode, true);
ffc14808: 80 98 00 00 lwz r4,0(r24)
ffc1480c: 7f 83 e3 78 mr r3,r28
ffc14810: 38 a1 00 08 addi r5,r1,8
ffc14814: 38 c0 00 01 li r6,1
ffc14818: 4b ff f7 c1 bl ffc13fd8 <rtems_rfs_inode_open>
if (rc > 0)
ffc1481c: 7c 75 1b 79 mr. r21,r3
ffc14820: 40 81 00 58 ble- ffc14878 <rtems_rfs_inode_create+0x21c><== ALWAYS TAKEN
}
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
rtems_rfs_inode_free (fs, *ino);
ffc14824: 80 98 00 00 lwz r4,0(r24) <== NOT EXECUTED
ffc14828: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc1482c: 4b ff f6 b1 bl ffc13edc <rtems_rfs_inode_free> <== NOT EXECUTED
return rc;
ffc14830: 4b ff ff 64 b ffc14794 <rtems_rfs_inode_create+0x138><== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
type = "dir";
ffc14834: 3e a0 ff c4 lis r21,-60 <== NOT EXECUTED
ffc14838: 3a b5 ba 4c addi r21,r21,-17844 <== NOT EXECUTED
ffc1483c: 2e 19 60 00 cmpwi cr4,r25,24576 <== NOT EXECUTED
ffc14840: 4b ff fe d8 b ffc14718 <rtems_rfs_inode_create+0xbc> <== NOT EXECUTED
else if (RTEMS_RFS_S_ISCHR (mode))
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
type = "block";
ffc14844: 3e a0 ff c4 lis r21,-60 <== NOT EXECUTED
ffc14848: 3a b5 b8 70 addi r21,r21,-18320 <== NOT EXECUTED
ffc1484c: 4b ff fe cc b ffc14718 <rtems_rfs_inode_create+0xbc> <== NOT EXECUTED
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
type = "char";
ffc14850: 3e a0 ff c4 lis r21,-60 <== NOT EXECUTED
ffc14854: 3a b5 ba 50 addi r21,r21,-17840 <== NOT EXECUTED
ffc14858: 2e 19 60 00 cmpwi cr4,r25,24576 <== NOT EXECUTED
ffc1485c: 4b ff fe bc b ffc14718 <rtems_rfs_inode_create+0xbc> <== NOT EXECUTED
else if (RTEMS_RFS_S_ISBLK (mode))
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
ffc14860: 3e a0 ff c4 lis r21,-60 <== NOT EXECUTED
ffc14864: 3a b5 9d c0 addi r21,r21,-25152 <== NOT EXECUTED
ffc14868: 4b ff fe b0 b ffc14718 <rtems_rfs_inode_create+0xbc> <== NOT EXECUTED
else if (RTEMS_RFS_S_ISLNK (mode))
type = "link";
ffc1486c: 3e a0 ff c4 lis r21,-60 <== NOT EXECUTED
ffc14870: 3a b5 ba 60 addi r21,r21,-17824 <== NOT EXECUTED
ffc14874: 4b ff fe a4 b ffc14718 <rtems_rfs_inode_create+0xbc> <== NOT EXECUTED
{
rtems_rfs_inode_free (fs, *ino);
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
ffc14878: 38 61 00 08 addi r3,r1,8
ffc1487c: 7f 44 d3 78 mr r4,r26
ffc14880: 7f 65 db 78 mr r5,r27
ffc14884: 7e e6 bb 78 mr r6,r23
ffc14888: 7e c7 b3 78 mr r7,r22
ffc1488c: 4b ff fc 69 bl ffc144f4 <rtems_rfs_inode_initialise>
if (rc > 0)
ffc14890: 7c 75 1b 79 mr. r21,r3
ffc14894: 41 81 00 44 bgt- ffc148d8 <rtems_rfs_inode_create+0x27c><== NEVER TAKEN
/*
* Only handle the specifics of a directory. Let caller handle the others.
*
* The inode delete will free the inode.
*/
if (RTEMS_RFS_S_ISDIR (mode))
ffc14898: 2e 19 40 00 cmpwi cr4,r25,16384
ffc1489c: 41 92 00 ac beq- cr4,ffc14948 <rtems_rfs_inode_create+0x2ec>
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
ffc148a0: 7f 83 e3 78 mr r3,r28
ffc148a4: 7f a4 eb 78 mr r4,r29
ffc148a8: 38 a1 00 30 addi r5,r1,48
ffc148ac: 38 c0 00 01 li r6,1
ffc148b0: 4b ff f7 29 bl ffc13fd8 <rtems_rfs_inode_open>
if (rc > 0)
ffc148b4: 7c 75 1b 79 mr. r21,r3
ffc148b8: 40 81 00 3c ble- ffc148f4 <rtems_rfs_inode_create+0x298><== ALWAYS TAKEN
{
rtems_rfs_inode_delete (fs, &inode);
ffc148bc: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc148c0: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc148c4: 4b ff fa 55 bl ffc14318 <rtems_rfs_inode_delete> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
ffc148c8: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc148cc: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc148d0: 4b ff f9 69 bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
ffc148d4: 4b ff fe c0 b ffc14794 <rtems_rfs_inode_create+0x138><== NOT EXECUTED
}
rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &inode);
ffc148d8: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc148dc: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc148e0: 4b ff f9 59 bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_free (fs, *ino);
ffc148e4: 80 98 00 00 lwz r4,0(r24) <== NOT EXECUTED
ffc148e8: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc148ec: 4b ff f5 f1 bl ffc13edc <rtems_rfs_inode_free> <== NOT EXECUTED
return rc;
ffc148f0: 4b ff fe a4 b ffc14794 <rtems_rfs_inode_create+0x138><== NOT EXECUTED
rtems_rfs_inode_delete (fs, &inode);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
ffc148f4: 80 f8 00 00 lwz r7,0(r24)
ffc148f8: 7f 83 e3 78 mr r3,r28
ffc148fc: 38 81 00 30 addi r4,r1,48
ffc14900: 7f c5 f3 78 mr r5,r30
ffc14904: 7f e6 fb 78 mr r6,r31
ffc14908: 48 00 ed 8d bl ffc23694 <rtems_rfs_dir_add_entry>
if (rc > 0)
ffc1490c: 7c 75 1b 79 mr. r21,r3
ffc14910: 41 81 00 8c bgt- ffc1499c <rtems_rfs_inode_create+0x340><== NEVER TAKEN
/*
* If the node is a directory update the parent link count as the
* new directory has the '..' link that points to the parent.
*/
if (RTEMS_RFS_S_ISDIR (mode))
ffc14914: 41 92 00 c4 beq- cr4,ffc149d8 <rtems_rfs_inode_create+0x37c>
rtems_rfs_inode_set_links (&parent_inode,
rtems_rfs_inode_get_links (&parent_inode) + 1);
rc = rtems_rfs_inode_close (fs, &parent_inode);
ffc14918: 38 81 00 30 addi r4,r1,48
ffc1491c: 7f 83 e3 78 mr r3,r28
ffc14920: 4b ff f9 19 bl ffc14238 <rtems_rfs_inode_close>
if (rc > 0)
{
rtems_rfs_inode_delete (fs, &inode);
ffc14924: 38 81 00 08 addi r4,r1,8
if (RTEMS_RFS_S_ISDIR (mode))
rtems_rfs_inode_set_links (&parent_inode,
rtems_rfs_inode_get_links (&parent_inode) + 1);
rc = rtems_rfs_inode_close (fs, &parent_inode);
if (rc > 0)
ffc14928: 7c 75 1b 79 mr. r21,r3
{
rtems_rfs_inode_delete (fs, &inode);
ffc1492c: 7f 83 e3 78 mr r3,r28
if (RTEMS_RFS_S_ISDIR (mode))
rtems_rfs_inode_set_links (&parent_inode,
rtems_rfs_inode_get_links (&parent_inode) + 1);
rc = rtems_rfs_inode_close (fs, &parent_inode);
if (rc > 0)
ffc14930: 40 81 00 94 ble- ffc149c4 <rtems_rfs_inode_create+0x368><== ALWAYS TAKEN
{
rtems_rfs_inode_delete (fs, &inode);
ffc14934: 4b ff f9 e5 bl ffc14318 <rtems_rfs_inode_delete> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
ffc14938: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc1493c: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc14940: 4b ff f8 f9 bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
ffc14944: 4b ff fe 50 b ffc14794 <rtems_rfs_inode_create+0x138><== NOT EXECUTED
*
* The inode delete will free the inode.
*/
if (RTEMS_RFS_S_ISDIR (mode))
{
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);
ffc14948: 80 f8 00 00 lwz r7,0(r24)
ffc1494c: 3c a0 ff c4 lis r5,-60
ffc14950: 7f 83 e3 78 mr r3,r28
ffc14954: 38 81 00 08 addi r4,r1,8
ffc14958: 38 a5 9e 0c addi r5,r5,-25076
ffc1495c: 38 c0 00 01 li r6,1
ffc14960: 48 00 ed 35 bl ffc23694 <rtems_rfs_dir_add_entry>
if (rc == 0)
ffc14964: 7c 75 1b 79 mr. r21,r3
ffc14968: 41 82 00 0c beq- ffc14974 <rtems_rfs_inode_create+0x318><== ALWAYS TAKEN
rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);
if (rc > 0)
ffc1496c: 40 81 ff 34 ble+ ffc148a0 <rtems_rfs_inode_create+0x244><== NOT EXECUTED
ffc14970: 4b ff ff 4c b ffc148bc <rtems_rfs_inode_create+0x260><== NOT EXECUTED
*/
if (RTEMS_RFS_S_ISDIR (mode))
{
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);
if (rc == 0)
rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);
ffc14974: 3c a0 ff c4 lis r5,-60
ffc14978: 7f 83 e3 78 mr r3,r28
ffc1497c: 38 81 00 08 addi r4,r1,8
ffc14980: 38 a5 9c b4 addi r5,r5,-25420
ffc14984: 38 c0 00 02 li r6,2
ffc14988: 7f a7 eb 78 mr r7,r29
ffc1498c: 48 00 ed 09 bl ffc23694 <rtems_rfs_dir_add_entry>
ffc14990: 7c 75 1b 79 mr. r21,r3
if (rc > 0)
ffc14994: 40 81 ff 0c ble+ ffc148a0 <rtems_rfs_inode_create+0x244><== ALWAYS TAKEN
ffc14998: 4b ff ff 24 b ffc148bc <rtems_rfs_inode_create+0x260><== NOT EXECUTED
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
if (rc > 0)
{
rtems_rfs_inode_delete (fs, &inode);
ffc1499c: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc149a0: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc149a4: 4b ff f9 75 bl ffc14318 <rtems_rfs_inode_delete> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
ffc149a8: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc149ac: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc149b0: 4b ff f8 89 bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
ffc149b4: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc149b8: 38 81 00 30 addi r4,r1,48 <== NOT EXECUTED
ffc149bc: 4b ff f8 7d bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
ffc149c0: 4b ff fd d4 b ffc14794 <rtems_rfs_inode_create+0x138><== NOT EXECUTED
rtems_rfs_inode_delete (fs, &inode);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &inode);
ffc149c4: 4b ff f8 75 bl ffc14238 <rtems_rfs_inode_close>
if (rc > 0)
ffc149c8: 7c 75 1b 79 mr. r21,r3
ffc149cc: 41 81 fe 58 bgt+ ffc14824 <rtems_rfs_inode_create+0x1c8><== NEVER TAKEN
{
rtems_rfs_inode_free (fs, *ino);
return rc;
}
return 0;
ffc149d0: 3a a0 00 00 li r21,0
ffc149d4: 4b ff fd c0 b ffc14794 <rtems_rfs_inode_create+0x138>
* If the node is a directory update the parent link count as the
* new directory has the '..' link that points to the parent.
*/
if (RTEMS_RFS_S_ISDIR (mode))
rtems_rfs_inode_set_links (&parent_inode,
rtems_rfs_inode_get_links (&parent_inode) + 1);
ffc149d8: 81 21 00 3c lwz r9,60(r1)
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
ffc149dc: 89 69 00 00 lbz r11,0(r9)
ffc149e0: 88 09 00 01 lbz r0,1(r9)
ffc149e4: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc149e8: 7d 6b 03 78 or r11,r11,r0
if (links == 0xffff)
ffc149ec: 6d 60 ff ff xoris r0,r11,65535
ffc149f0: 2f 80 ff ff cmpwi cr7,r0,-1
ffc149f4: 41 9e 00 28 beq- cr7,ffc14a1c <rtems_rfs_inode_create+0x3c0><== NEVER TAKEN
/*
* If the node is a directory update the parent link count as the
* new directory has the '..' link that points to the parent.
*/
if (RTEMS_RFS_S_ISDIR (mode))
rtems_rfs_inode_set_links (&parent_inode,
ffc149f8: 38 0b 00 01 addi r0,r11,1
ffc149fc: 54 00 04 3e clrlwi r0,r0,16
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
ffc14a00: 54 0b c2 3e rlwinm r11,r0,24,8,31
ffc14a04: 99 69 00 00 stb r11,0(r9)
ffc14a08: 81 21 00 3c lwz r9,60(r1)
ffc14a0c: 98 09 00 01 stb r0,1(r9)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc14a10: 38 00 00 01 li r0,1
ffc14a14: 98 01 00 40 stb r0,64(r1)
ffc14a18: 4b ff ff 00 b ffc14918 <rtems_rfs_inode_create+0x2bc>
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
if (links == 0xffff)
links = 0;
ffc14a1c: 39 60 00 00 li r11,0 <== NOT EXECUTED
ffc14a20: 4b ff ff d8 b ffc149f8 <rtems_rfs_inode_create+0x39c><== NOT EXECUTED
ffc14318 <rtems_rfs_inode_delete>:
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
ffc14318: 94 21 ff a0 stwu r1,-96(r1)
ffc1431c: 7c 08 02 a6 mflr r0
ffc14320: 93 c1 00 58 stw r30,88(r1)
ffc14324: 7c 7e 1b 78 mr r30,r3
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
ffc14328: 38 60 00 00 li r3,0
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
ffc1432c: 93 e1 00 5c stw r31,92(r1)
ffc14330: 7c 9f 23 78 mr r31,r4
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
ffc14334: 3c 80 00 80 lis r4,128
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
ffc14338: 90 01 00 64 stw r0,100(r1)
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
ffc1433c: 48 00 36 2d bl ffc17968 <rtems_rfs_trace>
ffc14340: 2f 83 00 00 cmpwi cr7,r3,0
ffc14344: 41 9e 00 2c beq- cr7,ffc14370 <rtems_rfs_inode_delete+0x58><== ALWAYS TAKEN
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
ffc14348: 80 1f 00 0c lwz r0,12(r31) <== NOT EXECUTED
ffc1434c: 80 9f 00 08 lwz r4,8(r31) <== NOT EXECUTED
ffc14350: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc14354: 41 9e 00 58 beq- cr7,ffc143ac <rtems_rfs_inode_delete+0x94><== NOT EXECUTED
ffc14358: 3c a0 ff c4 lis r5,-60 <== NOT EXECUTED
ffc1435c: 38 a5 b9 38 addi r5,r5,-18120 <== NOT EXECUTED
ffc14360: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc14364: 38 63 ba 20 addi r3,r3,-17888 <== NOT EXECUTED
ffc14368: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1436c: 48 01 69 d9 bl ffc2ad44 <printf> <== NOT EXECUTED
rtems_rfs_inode_ino (handle),
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
ffc14370: 80 1f 00 0c lwz r0,12(r31)
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
int rc = 0;
ffc14374: 38 60 00 00 li r3,0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
rtems_rfs_inode_ino (handle),
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
ffc14378: 2f 80 00 00 cmpwi cr7,r0,0
ffc1437c: 41 9e 00 18 beq- cr7,ffc14394 <rtems_rfs_inode_delete+0x7c><== NEVER TAKEN
rtems_rfs_block_map map;
/*
* Free the ino number.
*/
rc = rtems_rfs_inode_free (fs, handle->ino);
ffc14380: 80 9f 00 08 lwz r4,8(r31)
ffc14384: 7f c3 f3 78 mr r3,r30
ffc14388: 4b ff fb 55 bl ffc13edc <rtems_rfs_inode_free>
if (rc > 0)
ffc1438c: 2c 03 00 00 cmpwi r3,0
ffc14390: 40 81 00 28 ble- ffc143b8 <rtems_rfs_inode_delete+0xa0> <== ALWAYS TAKEN
handle->loads = 0;
handle->node = NULL;
}
}
return rc;
}
ffc14394: 80 01 00 64 lwz r0,100(r1)
ffc14398: 83 c1 00 58 lwz r30,88(r1)
ffc1439c: 7c 08 03 a6 mtlr r0
ffc143a0: 83 e1 00 5c lwz r31,92(r1)
ffc143a4: 38 21 00 60 addi r1,r1,96
ffc143a8: 4e 80 00 20 blr
rtems_rfs_inode_handle* handle)
{
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
ffc143ac: 3c a0 ff c4 lis r5,-60 <== NOT EXECUTED
ffc143b0: 38 a5 be 14 addi r5,r5,-16876 <== NOT EXECUTED
ffc143b4: 4b ff ff ac b ffc14360 <rtems_rfs_inode_delete+0x48> <== NOT EXECUTED
return rc;
/*
* Free the blocks the inode may have attached.
*/
rc = rtems_rfs_block_map_open (fs, handle, &map);
ffc143b8: 7f c3 f3 78 mr r3,r30
ffc143bc: 7f e4 fb 78 mr r4,r31
ffc143c0: 38 a1 00 08 addi r5,r1,8
ffc143c4: 48 00 d1 95 bl ffc21558 <rtems_rfs_block_map_open>
if (rc == 0)
ffc143c8: 2c 03 00 00 cmpwi r3,0
ffc143cc: 40 82 ff c8 bne+ ffc14394 <rtems_rfs_inode_delete+0x7c> <== NEVER TAKEN
{
int rrc;
rrc = rtems_rfs_block_map_free_all (fs, &map);
ffc143d0: 38 81 00 08 addi r4,r1,8
ffc143d4: 7f c3 f3 78 mr r3,r30
ffc143d8: 48 00 e0 01 bl ffc223d8 <rtems_rfs_block_map_free_all>
rc = rtems_rfs_block_map_close (fs, &map);
ffc143dc: 38 81 00 08 addi r4,r1,8
ffc143e0: 7f c3 f3 78 mr r3,r30
ffc143e4: 48 00 d3 7d bl ffc21760 <rtems_rfs_block_map_close>
if (rc > 0)
rrc = rc;
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
ffc143e8: 80 7f 00 0c lwz r3,12(r31)
ffc143ec: 38 80 00 ff li r4,255
ffc143f0: 38 a0 00 38 li r5,56
ffc143f4: 48 01 67 c1 bl ffc2abb4 <memset>
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc143f8: 38 00 00 01 li r0,1
ffc143fc: 7f e4 fb 78 mr r4,r31
ffc14400: 9c 04 00 10 stbu r0,16(r4)
/*
* Do the release here to avoid the ctime field being set on a
* close. Also if there loads is greater then one then other loads
* active. Forcing the loads count to 0.
*/
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
ffc14404: 7f c3 f3 78 mr r3,r30
ffc14408: 48 00 e2 39 bl ffc22640 <rtems_rfs_buffer_handle_release>
handle->loads = 0;
ffc1440c: 38 00 00 00 li r0,0
ffc14410: 90 1f 00 24 stw r0,36(r31)
handle->node = NULL;
ffc14414: 90 1f 00 0c stw r0,12(r31)
ffc14418: 4b ff ff 7c b ffc14394 <rtems_rfs_inode_delete+0x7c>
ffc13f04 <rtems_rfs_inode_load>:
}
int
rtems_rfs_inode_load (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
ffc13f04: 94 21 ff f0 stwu r1,-16(r1)
ffc13f08: 7c 08 02 a6 mflr r0
ffc13f0c: 93 c1 00 08 stw r30,8(r1)
ffc13f10: 7c 7e 1b 78 mr r30,r3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
ffc13f14: 38 60 00 00 li r3,0
}
int
rtems_rfs_inode_load (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
ffc13f18: 93 e1 00 0c stw r31,12(r1)
ffc13f1c: 7c 9f 23 78 mr r31,r4
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
ffc13f20: 3c 80 00 10 lis r4,16
}
int
rtems_rfs_inode_load (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
ffc13f24: 90 01 00 14 stw r0,20(r1)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
ffc13f28: 48 00 3a 41 bl ffc17968 <rtems_rfs_trace>
ffc13f2c: 2f 83 00 00 cmpwi cr7,r3,0
ffc13f30: 41 9e 00 30 beq- cr7,ffc13f60 <rtems_rfs_inode_load+0x5c><== ALWAYS TAKEN
printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
ffc13f34: 80 1f 00 0c lwz r0,12(r31) <== NOT EXECUTED
ffc13f38: 80 9f 00 08 lwz r4,8(r31) <== NOT EXECUTED
ffc13f3c: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc13f40: 80 bf 00 24 lwz r5,36(r31) <== NOT EXECUTED
ffc13f44: 41 9e 00 50 beq- cr7,ffc13f94 <rtems_rfs_inode_load+0x90><== NOT EXECUTED
ffc13f48: 3c c0 ff c4 lis r6,-60 <== NOT EXECUTED
ffc13f4c: 38 c6 b9 38 addi r6,r6,-18120 <== NOT EXECUTED
ffc13f50: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc13f54: 38 63 b9 3c addi r3,r3,-18116 <== NOT EXECUTED
ffc13f58: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc13f5c: 48 01 6d e9 bl ffc2ad44 <printf> <== NOT EXECUTED
/*
* An inode does not move so once loaded no need to do again.
*/
if (!rtems_rfs_inode_is_loaded (handle))
ffc13f60: 80 1f 00 0c lwz r0,12(r31)
ffc13f64: 2f 80 00 00 cmpwi cr7,r0,0
ffc13f68: 41 9e 00 38 beq- cr7,ffc13fa0 <rtems_rfs_inode_load+0x9c>
handle->node = rtems_rfs_buffer_data (&handle->buffer);
handle->node += handle->offset;
}
handle->loads++;
ffc13f6c: 81 3f 00 24 lwz r9,36(r31)
return 0;
ffc13f70: 38 60 00 00 li r3,0
handle->node = rtems_rfs_buffer_data (&handle->buffer);
handle->node += handle->offset;
}
handle->loads++;
ffc13f74: 38 09 00 01 addi r0,r9,1
ffc13f78: 90 1f 00 24 stw r0,36(r31)
return 0;
}
ffc13f7c: 80 01 00 14 lwz r0,20(r1)
ffc13f80: 83 c1 00 08 lwz r30,8(r1)
ffc13f84: 7c 08 03 a6 mtlr r0
ffc13f88: 83 e1 00 0c lwz r31,12(r1)
ffc13f8c: 38 21 00 10 addi r1,r1,16
ffc13f90: 4e 80 00 20 blr
int
rtems_rfs_inode_load (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
ffc13f94: 3c c0 ff c4 lis r6,-60 <== NOT EXECUTED
ffc13f98: 38 c6 be 14 addi r6,r6,-16876 <== NOT EXECUTED
ffc13f9c: 4b ff ff b4 b ffc13f50 <rtems_rfs_inode_load+0x4c> <== NOT EXECUTED
if (!rtems_rfs_inode_is_loaded (handle))
{
int rc;
rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
ffc13fa0: 80 bf 00 1c lwz r5,28(r31)
ffc13fa4: 7f c3 f3 78 mr r3,r30
ffc13fa8: 38 9f 00 10 addi r4,r31,16
ffc13fac: 38 c0 00 01 li r6,1
ffc13fb0: 48 00 e8 a5 bl ffc22854 <rtems_rfs_buffer_handle_request>
handle->block, true);
if (rc > 0)
ffc13fb4: 2c 03 00 00 cmpwi r3,0
ffc13fb8: 41 81 ff c4 bgt+ ffc13f7c <rtems_rfs_inode_load+0x78> <== NEVER TAKEN
return rc;
handle->node = rtems_rfs_buffer_data (&handle->buffer);
ffc13fbc: 81 3f 00 18 lwz r9,24(r31)
handle->node += handle->offset;
ffc13fc0: 80 1f 00 20 lwz r0,32(r31)
ffc13fc4: 81 29 00 24 lwz r9,36(r9)
ffc13fc8: 1c 00 00 38 mulli r0,r0,56
ffc13fcc: 7c 09 02 14 add r0,r9,r0
ffc13fd0: 90 1f 00 0c stw r0,12(r31)
ffc13fd4: 4b ff ff 98 b ffc13f6c <rtems_rfs_inode_load+0x68>
ffc13fd8 <rtems_rfs_inode_open>:
int
rtems_rfs_inode_open (rtems_rfs_file_system* fs,
rtems_rfs_ino ino,
rtems_rfs_inode_handle* handle,
bool load)
{
ffc13fd8: 94 21 ff e8 stwu r1,-24(r1)
ffc13fdc: 7c 08 02 a6 mflr r0
ffc13fe0: 93 c1 00 10 stw r30,16(r1)
ffc13fe4: 7c 7e 1b 78 mr r30,r3
int group;
int gino;
int index;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
ffc13fe8: 38 60 00 00 li r3,0
int
rtems_rfs_inode_open (rtems_rfs_file_system* fs,
rtems_rfs_ino ino,
rtems_rfs_inode_handle* handle,
bool load)
{
ffc13fec: 93 e1 00 14 stw r31,20(r1)
ffc13ff0: 7c 9f 23 78 mr r31,r4
int group;
int gino;
int index;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
ffc13ff4: 3c 80 00 04 lis r4,4
int
rtems_rfs_inode_open (rtems_rfs_file_system* fs,
rtems_rfs_ino ino,
rtems_rfs_inode_handle* handle,
bool load)
{
ffc13ff8: 93 81 00 08 stw r28,8(r1)
ffc13ffc: 7c dc 33 78 mr r28,r6
ffc14000: 93 a1 00 0c stw r29,12(r1)
ffc14004: 7c bd 2b 78 mr r29,r5
ffc14008: 90 01 00 1c stw r0,28(r1)
int group;
int gino;
int index;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
ffc1400c: 48 00 39 5d bl ffc17968 <rtems_rfs_trace>
ffc14010: 2f 83 00 00 cmpwi cr7,r3,0
ffc14014: 40 9e 00 cc bne- cr7,ffc140e0 <rtems_rfs_inode_open+0x108><== NEVER TAKEN
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
if (ino == RTEMS_RFS_EMPTY_INO)
ffc14018: 2f 9f 00 00 cmpwi cr7,r31,0
return EINVAL;
ffc1401c: 38 60 00 16 li r3,22
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
if (ino == RTEMS_RFS_EMPTY_INO)
ffc14020: 40 9e 00 24 bne- cr7,ffc14044 <rtems_rfs_inode_open+0x6c><== ALWAYS TAKEN
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
rc = rtems_rfs_inode_load (fs, handle);
return rc;
}
ffc14024: 80 01 00 1c lwz r0,28(r1) <== NOT EXECUTED
ffc14028: 83 81 00 08 lwz r28,8(r1) <== NOT EXECUTED
ffc1402c: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc14030: 83 a1 00 0c lwz r29,12(r1) <== NOT EXECUTED
ffc14034: 83 c1 00 10 lwz r30,16(r1) <== NOT EXECUTED
ffc14038: 83 e1 00 14 lwz r31,20(r1) <== NOT EXECUTED
ffc1403c: 38 21 00 18 addi r1,r1,24 <== NOT EXECUTED
ffc14040: 4e 80 00 20 blr <== NOT EXECUTED
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
if (ino == RTEMS_RFS_EMPTY_INO)
return EINVAL;
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
ffc14044: 81 3e 00 10 lwz r9,16(r30)
ffc14048: 38 1f ff ff addi r0,r31,-1
ffc1404c: 7f 80 48 40 cmplw cr7,r0,r9
ffc14050: 41 9d ff d4 bgt+ cr7,ffc14024 <rtems_rfs_inode_open+0x4c><== NEVER TAKEN
handle->ino = ino;
handle->node = NULL;
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
ffc14054: 81 5e 00 28 lwz r10,40(r30)
handle->offset = gino % fs->inodes_per_block;
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
ffc14058: 2f 9c 00 00 cmpwi cr7,r28,0
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
ffc1405c: 81 3e 00 2c lwz r9,44(r30)
handle->offset = gino % fs->inodes_per_block;
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
ffc14060: 38 60 00 00 li r3,0
handle->node = NULL;
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
ffc14064: 7d 60 53 96 divwu r11,r0,r10
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
ffc14068: 80 fe 00 1c lwz r7,28(r30)
return EINVAL;
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
return EINVAL;
handle->ino = ino;
ffc1406c: 93 fd 00 08 stw r31,8(r29)
handle->node = NULL;
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
ffc14070: 7d 4b 51 d6 mullw r10,r11,r10
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
ffc14074: 1d 0b 00 50 mulli r8,r11,80
handle->node = NULL;
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
ffc14078: 7c 0a 00 50 subf r0,r10,r0
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
ffc1407c: 7d 47 40 2e lwzx r10,r7,r8
handle->offset = gino % fs->inodes_per_block;
ffc14080: 7d 60 4b 96 divwu r11,r0,r9
ffc14084: 7d 0b 49 d6 mullw r8,r11,r9
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
ffc14088: 39 4a 00 02 addi r10,r10,2
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
return EINVAL;
handle->ino = ino;
handle->node = NULL;
ffc1408c: 39 20 00 00 li r9,0
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
ffc14090: 7c 08 00 50 subf r0,r8,r0
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
return EINVAL;
handle->ino = ino;
handle->node = NULL;
ffc14094: 91 3d 00 0c stw r9,12(r29)
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
ffc14098: 7d 6a 5a 14 add r11,r10,r11
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
return EINVAL;
handle->ino = ino;
handle->node = NULL;
handle->loads = 0;
ffc1409c: 91 3d 00 24 stw r9,36(r29)
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
ffc140a0: 90 1d 00 20 stw r0,32(r29)
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
ffc140a4: 91 7d 00 1c stw r11,28(r29)
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc140a8: 99 3d 00 10 stb r9,16(r29)
handle->bnum = 0;
ffc140ac: 91 3d 00 14 stw r9,20(r29)
handle->buffer = NULL;
ffc140b0: 91 3d 00 18 stw r9,24(r29)
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
ffc140b4: 41 9e ff 70 beq+ cr7,ffc14024 <rtems_rfs_inode_open+0x4c><== NEVER TAKEN
rc = rtems_rfs_inode_load (fs, handle);
return rc;
}
ffc140b8: 80 01 00 1c lwz r0,28(r1)
handle->offset = gino % fs->inodes_per_block;
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
rc = rtems_rfs_inode_load (fs, handle);
ffc140bc: 7f c3 f3 78 mr r3,r30
ffc140c0: 7f a4 eb 78 mr r4,r29
return rc;
}
ffc140c4: 83 81 00 08 lwz r28,8(r1)
ffc140c8: 7c 08 03 a6 mtlr r0
ffc140cc: 83 a1 00 0c lwz r29,12(r1)
ffc140d0: 83 c1 00 10 lwz r30,16(r1)
ffc140d4: 83 e1 00 14 lwz r31,20(r1)
ffc140d8: 38 21 00 18 addi r1,r1,24
handle->offset = gino % fs->inodes_per_block;
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
rc = rtems_rfs_inode_load (fs, handle);
ffc140dc: 4b ff fe 28 b ffc13f04 <rtems_rfs_inode_load>
int gino;
int index;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
ffc140e0: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc140e4: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc140e8: 38 63 b9 70 addi r3,r3,-18064 <== NOT EXECUTED
ffc140ec: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc140f0: 48 01 6c 55 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc140f4: 4b ff ff 24 b ffc14018 <rtems_rfs_inode_open+0x40> <== NOT EXECUTED
ffc1441c <rtems_rfs_inode_time_stamp_now>:
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
ffc1441c: 94 21 ff e8 stwu r1,-24(r1)
ffc14420: 7c 08 02 a6 mflr r0
ffc14424: 90 01 00 1c stw r0,28(r1)
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
ffc14428: 80 03 00 0c lwz r0,12(r3)
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
ffc1442c: 93 a1 00 0c stw r29,12(r1)
ffc14430: 7c bd 2b 78 mr r29,r5
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
ffc14434: 2f 80 00 00 cmpwi cr7,r0,0
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
ffc14438: 93 c1 00 10 stw r30,16(r1)
ffc1443c: 7c 9e 23 78 mr r30,r4
ffc14440: 93 e1 00 14 stw r31,20(r1)
ffc14444: 7c 7f 1b 78 mr r31,r3
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
return ENXIO;
ffc14448: 38 60 00 06 li r3,6
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
ffc1444c: 41 9e 00 8c beq- cr7,ffc144d8 <rtems_rfs_inode_time_stamp_now+0xbc><== NEVER TAKEN
return ENXIO;
now = time (NULL);
ffc14450: 38 60 00 00 li r3,0
ffc14454: 48 01 a1 71 bl ffc2e5c4 <time>
if (atime)
ffc14458: 2f 9e 00 00 cmpwi cr7,r30,0
bool mtime)
{
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
return ENXIO;
now = time (NULL);
ffc1445c: 7c 60 1b 78 mr r0,r3
if (atime)
ffc14460: 41 9e 00 38 beq- cr7,ffc14498 <rtems_rfs_inode_time_stamp_now+0x7c><== NEVER TAKEN
*/
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
ffc14464: 81 3f 00 0c lwz r9,12(r31)
ffc14468: 54 6b 46 3e rlwinm r11,r3,8,24,31
ffc1446c: 54 6a 84 3e rlwinm r10,r3,16,16,31
ffc14470: 99 69 00 10 stb r11,16(r9)
ffc14474: 54 6b c2 3e rlwinm r11,r3,24,8,31
ffc14478: 81 3f 00 0c lwz r9,12(r31)
ffc1447c: 99 49 00 11 stb r10,17(r9)
ffc14480: 81 3f 00 0c lwz r9,12(r31)
ffc14484: 99 69 00 12 stb r11,18(r9)
ffc14488: 81 3f 00 0c lwz r9,12(r31)
ffc1448c: 98 69 00 13 stb r3,19(r9)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc14490: 39 20 00 01 li r9,1
ffc14494: 99 3f 00 10 stb r9,16(r31)
rtems_rfs_inode_set_atime (handle, now);
if (mtime)
ffc14498: 2f 9d 00 00 cmpwi cr7,r29,0
rtems_rfs_inode_set_mtime (handle, now);
return 0;
ffc1449c: 38 60 00 00 li r3,0
if (!rtems_rfs_inode_is_loaded (handle))
return ENXIO;
now = time (NULL);
if (atime)
rtems_rfs_inode_set_atime (handle, now);
if (mtime)
ffc144a0: 41 9e 00 38 beq- cr7,ffc144d8 <rtems_rfs_inode_time_stamp_now+0xbc><== NEVER TAKEN
*/
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
ffc144a4: 81 3f 00 0c lwz r9,12(r31)
ffc144a8: 54 0b 46 3e rlwinm r11,r0,8,24,31
ffc144ac: 54 0a 84 3e rlwinm r10,r0,16,16,31
ffc144b0: 99 69 00 14 stb r11,20(r9)
ffc144b4: 54 0b c2 3e rlwinm r11,r0,24,8,31
ffc144b8: 81 3f 00 0c lwz r9,12(r31)
ffc144bc: 99 49 00 15 stb r10,21(r9)
ffc144c0: 81 3f 00 0c lwz r9,12(r31)
ffc144c4: 99 69 00 16 stb r11,22(r9)
ffc144c8: 81 3f 00 0c lwz r9,12(r31)
ffc144cc: 98 09 00 17 stb r0,23(r9)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc144d0: 38 00 00 01 li r0,1
ffc144d4: 98 1f 00 10 stb r0,16(r31)
rtems_rfs_inode_set_mtime (handle, now);
return 0;
}
ffc144d8: 80 01 00 1c lwz r0,28(r1)
ffc144dc: 83 a1 00 0c lwz r29,12(r1)
ffc144e0: 7c 08 03 a6 mtlr r0
ffc144e4: 83 c1 00 10 lwz r30,16(r1)
ffc144e8: 83 e1 00 14 lwz r31,20(r1)
ffc144ec: 38 21 00 18 addi r1,r1,24
ffc144f0: 4e 80 00 20 blr
ffc140f8 <rtems_rfs_inode_unload>:
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
ffc140f8: 94 21 ff e8 stwu r1,-24(r1)
ffc140fc: 7c 08 02 a6 mflr r0
ffc14100: 93 c1 00 10 stw r30,16(r1)
ffc14104: 7c 7e 1b 78 mr r30,r3
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
ffc14108: 38 60 00 00 li r3,0
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
ffc1410c: 93 e1 00 14 stw r31,20(r1)
ffc14110: 7c 9f 23 78 mr r31,r4
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
ffc14114: 3c 80 00 20 lis r4,32
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
ffc14118: 93 a1 00 0c stw r29,12(r1)
ffc1411c: 7c bd 2b 78 mr r29,r5
ffc14120: 90 01 00 1c stw r0,28(r1)
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
ffc14124: 48 00 38 45 bl ffc17968 <rtems_rfs_trace>
ffc14128: 2f 83 00 00 cmpwi cr7,r3,0
ffc1412c: 41 9e 00 30 beq- cr7,ffc1415c <rtems_rfs_inode_unload+0x64><== ALWAYS TAKEN
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
ffc14130: 80 1f 00 0c lwz r0,12(r31) <== NOT EXECUTED
ffc14134: 80 9f 00 08 lwz r4,8(r31) <== NOT EXECUTED
ffc14138: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc1413c: 80 bf 00 24 lwz r5,36(r31) <== NOT EXECUTED
ffc14140: 41 9e 00 b0 beq- cr7,ffc141f0 <rtems_rfs_inode_unload+0xf8><== NOT EXECUTED
ffc14144: 3c c0 ff c4 lis r6,-60 <== NOT EXECUTED
ffc14148: 38 c6 b9 38 addi r6,r6,-18120 <== NOT EXECUTED
ffc1414c: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc14150: 38 63 b9 94 addi r3,r3,-18028 <== NOT EXECUTED
ffc14154: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc14158: 48 01 6b ed bl ffc2ad44 <printf> <== NOT EXECUTED
handle->ino, handle->loads,
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
ffc1415c: 80 1f 00 0c lwz r0,12(r31)
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
int rc = 0;
ffc14160: 38 60 00 00 li r3,0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
handle->ino, handle->loads,
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
ffc14164: 2f 80 00 00 cmpwi cr7,r0,0
ffc14168: 41 9e 00 14 beq- cr7,ffc1417c <rtems_rfs_inode_unload+0x84>
{
if (handle->loads == 0)
ffc1416c: 81 3f 00 24 lwz r9,36(r31)
return EIO;
ffc14170: 38 60 00 05 li r3,5
handle->ino, handle->loads,
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
{
if (handle->loads == 0)
ffc14174: 2f 89 00 00 cmpwi cr7,r9,0
ffc14178: 40 9e 00 20 bne- cr7,ffc14198 <rtems_rfs_inode_unload+0xa0><== ALWAYS TAKEN
handle->node = NULL;
}
}
return rc;
}
ffc1417c: 80 01 00 1c lwz r0,28(r1)
ffc14180: 83 a1 00 0c lwz r29,12(r1)
ffc14184: 7c 08 03 a6 mtlr r0
ffc14188: 83 c1 00 10 lwz r30,16(r1)
ffc1418c: 83 e1 00 14 lwz r31,20(r1)
ffc14190: 38 21 00 18 addi r1,r1,24
ffc14194: 4e 80 00 20 blr
if (rtems_rfs_inode_is_loaded (handle))
{
if (handle->loads == 0)
return EIO;
handle->loads--;
ffc14198: 39 29 ff ff addi r9,r9,-1
if (handle->loads == 0)
ffc1419c: 2f 89 00 00 cmpwi cr7,r9,0
if (rtems_rfs_inode_is_loaded (handle))
{
if (handle->loads == 0)
return EIO;
handle->loads--;
ffc141a0: 91 3f 00 24 stw r9,36(r31)
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
int rc = 0;
ffc141a4: 38 60 00 00 li r3,0
if (handle->loads == 0)
return EIO;
handle->loads--;
if (handle->loads == 0)
ffc141a8: 40 be ff d4 bne- cr7,ffc1417c <rtems_rfs_inode_unload+0x84>
{
/*
* If the buffer is dirty it will be release. Also set the ctime.
*/
if (rtems_rfs_buffer_dirty (&handle->buffer) && update_ctime)
ffc141ac: 88 1f 00 10 lbz r0,16(r31)
ffc141b0: 2f 80 00 00 cmpwi cr7,r0,0
ffc141b4: 41 9e 00 0c beq- cr7,ffc141c0 <rtems_rfs_inode_unload+0xc8>
ffc141b8: 2f 9d 00 00 cmpwi cr7,r29,0
ffc141bc: 40 9e 00 40 bne- cr7,ffc141fc <rtems_rfs_inode_unload+0x104><== ALWAYS TAKEN
rtems_rfs_inode_set_ctime (handle, time (NULL));
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
ffc141c0: 7f c3 f3 78 mr r3,r30
ffc141c4: 38 9f 00 10 addi r4,r31,16
ffc141c8: 48 00 e4 79 bl ffc22640 <rtems_rfs_buffer_handle_release>
handle->node = NULL;
ffc141cc: 38 00 00 00 li r0,0
ffc141d0: 90 1f 00 0c stw r0,12(r31)
}
}
return rc;
}
ffc141d4: 80 01 00 1c lwz r0,28(r1)
ffc141d8: 83 a1 00 0c lwz r29,12(r1)
ffc141dc: 7c 08 03 a6 mtlr r0
ffc141e0: 83 c1 00 10 lwz r30,16(r1)
ffc141e4: 83 e1 00 14 lwz r31,20(r1)
ffc141e8: 38 21 00 18 addi r1,r1,24
ffc141ec: 4e 80 00 20 blr
bool update_ctime)
{
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
ffc141f0: 3c c0 ff c4 lis r6,-60 <== NOT EXECUTED
ffc141f4: 38 c6 be 14 addi r6,r6,-16876 <== NOT EXECUTED
ffc141f8: 4b ff ff 54 b ffc1414c <rtems_rfs_inode_unload+0x54> <== NOT EXECUTED
{
/*
* If the buffer is dirty it will be release. Also set the ctime.
*/
if (rtems_rfs_buffer_dirty (&handle->buffer) && update_ctime)
rtems_rfs_inode_set_ctime (handle, time (NULL));
ffc141fc: 48 01 a3 c9 bl ffc2e5c4 <time>
*/
static inline void
rtems_rfs_inode_set_ctime (rtems_rfs_inode_handle* handle,
rtems_rfs_time ctime)
{
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
ffc14200: 81 3f 00 0c lwz r9,12(r31)
ffc14204: 54 60 46 3e rlwinm r0,r3,8,24,31
ffc14208: 98 09 00 18 stb r0,24(r9)
ffc1420c: 54 6b 84 3e rlwinm r11,r3,16,16,31
ffc14210: 54 60 c2 3e rlwinm r0,r3,24,8,31
ffc14214: 81 3f 00 0c lwz r9,12(r31)
ffc14218: 99 69 00 19 stb r11,25(r9)
ffc1421c: 81 3f 00 0c lwz r9,12(r31)
ffc14220: 98 09 00 1a stb r0,26(r9)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc14224: 38 00 00 01 li r0,1
*/
static inline void
rtems_rfs_inode_set_ctime (rtems_rfs_inode_handle* handle,
rtems_rfs_time ctime)
{
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
ffc14228: 81 3f 00 0c lwz r9,12(r31)
ffc1422c: 98 69 00 1b stb r3,27(r9)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc14230: 98 1f 00 10 stb r0,16(r31)
ffc14234: 4b ff ff 8c b ffc141c0 <rtems_rfs_inode_unload+0xc8>
ffc26308 <rtems_rfs_link>:
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
ffc26308: 94 21 ff 88 stwu r1,-120(r1)
ffc2630c: 7c 08 02 a6 mflr r0
ffc26310: 93 a1 00 6c stw r29,108(r1)
ffc26314: 7c 7d 1b 78 mr r29,r3
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle target_inode;
uint16_t links;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))
ffc26318: 38 60 00 00 li r3,0
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
ffc2631c: 93 c1 00 70 stw r30,112(r1)
ffc26320: 7c 9e 23 78 mr r30,r4
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle target_inode;
uint16_t links;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))
ffc26324: 3c 80 01 00 lis r4,256
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
ffc26328: 93 41 00 60 stw r26,96(r1)
ffc2632c: 7d 1a 43 78 mr r26,r8
ffc26330: 93 61 00 64 stw r27,100(r1)
ffc26334: 7c fb 3b 78 mr r27,r7
ffc26338: 93 81 00 68 stw r28,104(r1)
ffc2633c: 7c dc 33 78 mr r28,r6
ffc26340: 93 e1 00 74 stw r31,116(r1)
ffc26344: 7c bf 2b 78 mr r31,r5
ffc26348: 90 01 00 7c stw r0,124(r1)
ffc2634c: 93 21 00 5c stw r25,92(r1)
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle target_inode;
uint16_t links;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))
ffc26350: 4b ff 16 19 bl ffc17968 <rtems_rfs_trace>
ffc26354: 2f 83 00 00 cmpwi cr7,r3,0
ffc26358: 40 9e 01 70 bne- cr7,ffc264c8 <rtems_rfs_link+0x1c0> <== NEVER TAKEN
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
}
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
ffc2635c: 7f a3 eb 78 mr r3,r29
ffc26360: 7f 64 db 78 mr r4,r27
ffc26364: 38 a1 00 08 addi r5,r1,8
ffc26368: 38 c0 00 01 li r6,1
ffc2636c: 4b fe dc 6d bl ffc13fd8 <rtems_rfs_inode_open>
if (rc)
ffc26370: 7c 79 1b 79 mr. r25,r3
ffc26374: 40 82 00 dc bne- ffc26450 <rtems_rfs_link+0x148> <== NEVER TAKEN
/*
* If the target inode is a directory and we cannot link directories
* return a not supported error code.
*/
if (!link_dir && S_ISDIR (rtems_rfs_inode_get_mode (&target_inode)))
ffc26378: 2f 9a 00 00 cmpwi cr7,r26,0
{
rtems_rfs_inode_close (fs, &target_inode);
ffc2637c: 7f a3 eb 78 mr r3,r29
/*
* If the target inode is a directory and we cannot link directories
* return a not supported error code.
*/
if (!link_dir && S_ISDIR (rtems_rfs_inode_get_mode (&target_inode)))
ffc26380: 40 9e 00 18 bne- cr7,ffc26398 <rtems_rfs_link+0x90> <== NEVER TAKEN
ffc26384: 81 21 00 14 lwz r9,20(r1)
ffc26388: 88 09 00 02 lbz r0,2(r9)
ffc2638c: 54 00 44 26 rlwinm r0,r0,8,16,19
ffc26390: 2f 80 40 00 cmpwi cr7,r0,16384
ffc26394: 41 9e 01 80 beq- cr7,ffc26514 <rtems_rfs_link+0x20c> <== NEVER TAKEN
{
rtems_rfs_inode_close (fs, &target_inode);
return ENOTSUP;
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
ffc26398: 7f 84 e3 78 mr r4,r28
ffc2639c: 38 a1 00 30 addi r5,r1,48
ffc263a0: 38 c0 00 01 li r6,1
ffc263a4: 4b fe dc 35 bl ffc13fd8 <rtems_rfs_inode_open>
if (rc)
ffc263a8: 7c 79 1b 79 mr. r25,r3
{
rtems_rfs_inode_close (fs, &target_inode);
ffc263ac: 7f a3 eb 78 mr r3,r29
rtems_rfs_inode_close (fs, &target_inode);
return ENOTSUP;
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
if (rc)
ffc263b0: 40 82 00 e0 bne- ffc26490 <rtems_rfs_link+0x188> <== NEVER TAKEN
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
ffc263b4: 38 81 00 30 addi r4,r1,48
ffc263b8: 7f c5 f3 78 mr r5,r30
ffc263bc: 7f e6 fb 78 mr r6,r31
ffc263c0: 7f 67 db 78 mr r7,r27
ffc263c4: 4b ff d2 d1 bl ffc23694 <rtems_rfs_dir_add_entry>
if (rc > 0)
ffc263c8: 7c 79 1b 79 mr. r25,r3
ffc263cc: 41 81 00 b4 bgt- ffc26480 <rtems_rfs_link+0x178> <== NEVER TAKEN
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
links = rtems_rfs_inode_get_links (&target_inode) + 1;
ffc263d0: 81 21 00 14 lwz r9,20(r1)
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
if (links == 0xffff)
ffc263d4: 39 60 00 00 li r11,0
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
ffc263d8: 89 49 00 00 lbz r10,0(r9)
ffc263dc: 88 09 00 01 lbz r0,1(r9)
ffc263e0: 55 4a 40 2e rlwinm r10,r10,8,0,23
ffc263e4: 7d 4a 03 78 or r10,r10,r0
if (links == 0xffff)
ffc263e8: 38 00 00 00 li r0,0
ffc263ec: 60 00 ff ff ori r0,r0,65535
ffc263f0: 7f 8a 00 00 cmpw cr7,r10,r0
ffc263f4: 38 00 00 01 li r0,1
ffc263f8: 41 9e 00 14 beq- cr7,ffc2640c <rtems_rfs_link+0x104> <== NEVER TAKEN
ffc263fc: 38 0a 00 01 addi r0,r10,1
ffc26400: 54 00 04 3e clrlwi r0,r0,16
ffc26404: 54 0b c2 3e rlwinm r11,r0,24,8,31
ffc26408: 54 00 06 3e clrlwi r0,r0,24
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
ffc2640c: 99 69 00 00 stb r11,0(r9)
rtems_rfs_inode_set_links (&target_inode, links);
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
ffc26410: 38 80 00 01 li r4,1
ffc26414: 38 61 00 30 addi r3,r1,48
ffc26418: 81 21 00 14 lwz r9,20(r1)
ffc2641c: 38 a0 00 01 li r5,1
ffc26420: 98 09 00 01 stb r0,1(r9)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc26424: 38 00 00 01 li r0,1
ffc26428: 98 01 00 18 stb r0,24(r1)
ffc2642c: 4b fe df f1 bl ffc1441c <rtems_rfs_inode_time_stamp_now>
if (rc > 0)
ffc26430: 7c 79 1b 79 mr. r25,r3
{
rtems_rfs_inode_close (fs, &parent_inode);
ffc26434: 38 81 00 30 addi r4,r1,48
ffc26438: 7f a3 eb 78 mr r3,r29
links = rtems_rfs_inode_get_links (&target_inode) + 1;
rtems_rfs_inode_set_links (&target_inode, links);
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
if (rc > 0)
ffc2643c: 40 81 01 14 ble- ffc26550 <rtems_rfs_link+0x248> <== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &parent_inode);
ffc26440: 4b fe dd f9 bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
ffc26444: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc26448: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc2644c: 4b fe dd ed bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
ffc26450: 80 01 00 7c lwz r0,124(r1)
ffc26454: 7f 23 cb 78 mr r3,r25
ffc26458: 83 41 00 60 lwz r26,96(r1)
ffc2645c: 7c 08 03 a6 mtlr r0
ffc26460: 83 21 00 5c lwz r25,92(r1)
ffc26464: 83 61 00 64 lwz r27,100(r1)
ffc26468: 83 81 00 68 lwz r28,104(r1)
ffc2646c: 83 a1 00 6c lwz r29,108(r1)
ffc26470: 83 c1 00 70 lwz r30,112(r1)
ffc26474: 83 e1 00 74 lwz r31,116(r1)
ffc26478: 38 21 00 78 addi r1,r1,120
ffc2647c: 4e 80 00 20 blr
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &parent_inode);
ffc26480: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc26484: 38 81 00 30 addi r4,r1,48 <== NOT EXECUTED
ffc26488: 4b fe dd b1 bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
ffc2648c: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc26490: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc26494: 4b fe dd a5 bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
ffc26498: 80 01 00 7c lwz r0,124(r1) <== NOT EXECUTED
ffc2649c: 7f 23 cb 78 mr r3,r25 <== NOT EXECUTED
ffc264a0: 83 41 00 60 lwz r26,96(r1) <== NOT EXECUTED
ffc264a4: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc264a8: 83 21 00 5c lwz r25,92(r1) <== NOT EXECUTED
ffc264ac: 83 61 00 64 lwz r27,100(r1) <== NOT EXECUTED
ffc264b0: 83 81 00 68 lwz r28,104(r1) <== NOT EXECUTED
ffc264b4: 83 a1 00 6c lwz r29,108(r1) <== NOT EXECUTED
ffc264b8: 83 c1 00 70 lwz r30,112(r1) <== NOT EXECUTED
ffc264bc: 83 e1 00 74 lwz r31,116(r1) <== NOT EXECUTED
ffc264c0: 38 21 00 78 addi r1,r1,120 <== NOT EXECUTED
ffc264c4: 4e 80 00 20 blr <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))
{
int c;
printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);
ffc264c8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc264cc: 38 63 da 38 addi r3,r3,-9672 <== NOT EXECUTED
ffc264d0: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc264d4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc264d8: 48 00 48 6d bl ffc2ad44 <printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
ffc264dc: 2f 9f 00 00 cmpwi cr7,r31,0 <== NOT EXECUTED
ffc264e0: 40 9d 00 1c ble- cr7,ffc264fc <rtems_rfs_link+0x1f4> <== NOT EXECUTED
ffc264e4: 3b 20 00 00 li r25,0 <== NOT EXECUTED
printf ("%c", name[c]);
ffc264e8: 7c 7e c8 ae lbzx r3,r30,r25 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))
{
int c;
printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);
for (c = 0; c < length; c++)
ffc264ec: 3b 39 00 01 addi r25,r25,1 <== NOT EXECUTED
printf ("%c", name[c]);
ffc264f0: 48 00 49 11 bl ffc2ae00 <putchar> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))
{
int c;
printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);
for (c = 0; c < length; c++)
ffc264f4: 7f 99 f8 00 cmpw cr7,r25,r31 <== NOT EXECUTED
ffc264f8: 40 9e ff f0 bne+ cr7,ffc264e8 <rtems_rfs_link+0x1e0> <== NOT EXECUTED
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
ffc264fc: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc26500: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc26504: 38 63 da 80 addi r3,r3,-9600 <== NOT EXECUTED
ffc26508: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc2650c: 48 00 48 39 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc26510: 4b ff fe 4c b ffc2635c <rtems_rfs_link+0x54> <== NOT EXECUTED
* If the target inode is a directory and we cannot link directories
* return a not supported error code.
*/
if (!link_dir && S_ISDIR (rtems_rfs_inode_get_mode (&target_inode)))
{
rtems_rfs_inode_close (fs, &target_inode);
ffc26514: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc26518: 4b fe dd 21 bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
ffc2651c: 80 01 00 7c lwz r0,124(r1) <== NOT EXECUTED
* return a not supported error code.
*/
if (!link_dir && S_ISDIR (rtems_rfs_inode_get_mode (&target_inode)))
{
rtems_rfs_inode_close (fs, &target_inode);
return ENOTSUP;
ffc26520: 3b 20 00 86 li r25,134 <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
ffc26524: 83 41 00 60 lwz r26,96(r1) <== NOT EXECUTED
ffc26528: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc2652c: 7f 23 cb 78 mr r3,r25 <== NOT EXECUTED
ffc26530: 83 61 00 64 lwz r27,100(r1) <== NOT EXECUTED
ffc26534: 83 21 00 5c lwz r25,92(r1) <== NOT EXECUTED
ffc26538: 83 81 00 68 lwz r28,104(r1) <== NOT EXECUTED
ffc2653c: 83 a1 00 6c lwz r29,108(r1) <== NOT EXECUTED
ffc26540: 83 c1 00 70 lwz r30,112(r1) <== NOT EXECUTED
ffc26544: 83 e1 00 74 lwz r31,116(r1) <== NOT EXECUTED
ffc26548: 38 21 00 78 addi r1,r1,120 <== NOT EXECUTED
ffc2654c: 4e 80 00 20 blr <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
ffc26550: 4b fe dc e9 bl ffc14238 <rtems_rfs_inode_close>
if (rc > 0)
{
rtems_rfs_inode_close (fs, &target_inode);
ffc26554: 38 81 00 08 addi r4,r1,8
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
if (rc > 0)
ffc26558: 7c 79 1b 79 mr. r25,r3
{
rtems_rfs_inode_close (fs, &target_inode);
ffc2655c: 7f a3 eb 78 mr r3,r29
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
if (rc > 0)
ffc26560: 41 81 ff 34 bgt+ ffc26494 <rtems_rfs_link+0x18c> <== NEVER TAKEN
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
ffc26564: 4b fe dc d5 bl ffc14238 <rtems_rfs_inode_close>
ffc26568: 7c 79 1b 78 mr r25,r3
return rc;
ffc2656c: 4b ff fe e4 b ffc26450 <rtems_rfs_link+0x148>
ffc26f64 <rtems_rfs_mutex_create>:
RTEMS_NO_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL)
#endif
int
rtems_rfs_mutex_create (rtems_rfs_mutex* mutex)
{
ffc26f64: 94 21 ff f0 stwu r1,-16(r1)
ffc26f68: 7c 08 02 a6 mflr r0
ffc26f6c: 7c 67 1b 78 mr r7,r3
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_create (rtems_build_name ('R', 'F', 'S', 'm'),
ffc26f70: 3c 60 52 46 lis r3,21062
RTEMS_NO_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL)
#endif
int
rtems_rfs_mutex_create (rtems_rfs_mutex* mutex)
{
ffc26f74: 93 c1 00 08 stw r30,8(r1)
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_create (rtems_build_name ('R', 'F', 'S', 'm'),
ffc26f78: 60 63 53 6d ori r3,r3,21357
ffc26f7c: 38 80 00 01 li r4,1
RTEMS_NO_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL)
#endif
int
rtems_rfs_mutex_create (rtems_rfs_mutex* mutex)
{
ffc26f80: 93 e1 00 0c stw r31,12(r1)
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_create (rtems_build_name ('R', 'F', 'S', 'm'),
ffc26f84: 38 a0 00 24 li r5,36
ffc26f88: 38 c0 00 00 li r6,0
RTEMS_NO_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL)
#endif
int
rtems_rfs_mutex_create (rtems_rfs_mutex* mutex)
{
ffc26f8c: 90 01 00 14 stw r0,20(r1)
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_create (rtems_build_name ('R', 'F', 'S', 'm'),
ffc26f90: 4b fe 65 25 bl ffc0d4b4 <rtems_semaphore_create>
printf ("rtems-rfs: mutex: open failed: %s\n",
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
ffc26f94: 3b e0 00 00 li r31,0
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_create (rtems_build_name ('R', 'F', 'S', 'm'),
1, RTEMS_RFS_MUTEX_ATTRIBS, 0,
mutex);
if (sc != RTEMS_SUCCESSFUL)
ffc26f98: 7c 7e 1b 79 mr. r30,r3
ffc26f9c: 40 82 00 20 bne- ffc26fbc <rtems_rfs_mutex_create+0x58> <== NEVER TAKEN
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
ffc26fa0: 80 01 00 14 lwz r0,20(r1)
ffc26fa4: 7f e3 fb 78 mr r3,r31
ffc26fa8: 83 c1 00 08 lwz r30,8(r1)
ffc26fac: 7c 08 03 a6 mtlr r0
ffc26fb0: 83 e1 00 0c lwz r31,12(r1)
ffc26fb4: 38 21 00 10 addi r1,r1,16
ffc26fb8: 4e 80 00 20 blr
sc = rtems_semaphore_create (rtems_build_name ('R', 'F', 'S', 'm'),
1, RTEMS_RFS_MUTEX_ATTRIBS, 0,
mutex);
if (sc != RTEMS_SUCCESSFUL)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc26fbc: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc26fc0: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc26fc4: 4b ff 09 a5 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
printf ("rtems-rfs: mutex: open failed: %s\n",
rtems_status_text (sc));
return EIO;
ffc26fc8: 3b e0 00 05 li r31,5 <== NOT EXECUTED
sc = rtems_semaphore_create (rtems_build_name ('R', 'F', 'S', 'm'),
1, RTEMS_RFS_MUTEX_ATTRIBS, 0,
mutex);
if (sc != RTEMS_SUCCESSFUL)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc26fcc: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc26fd0: 41 9e ff d0 beq+ cr7,ffc26fa0 <rtems_rfs_mutex_create+0x3c><== NOT EXECUTED
printf ("rtems-rfs: mutex: open failed: %s\n",
ffc26fd4: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc26fd8: 4b ff 58 65 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc26fdc: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc26fe0: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc26fe4: 38 63 dc 68 addi r3,r3,-9112 <== NOT EXECUTED
ffc26fe8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc26fec: 48 00 3d 59 bl ffc2ad44 <printf> <== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
ffc26ff0: 80 01 00 14 lwz r0,20(r1) <== NOT EXECUTED
ffc26ff4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc26ff8: 83 c1 00 08 lwz r30,8(r1) <== NOT EXECUTED
ffc26ffc: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc27000: 83 e1 00 0c lwz r31,12(r1) <== NOT EXECUTED
ffc27004: 38 21 00 10 addi r1,r1,16 <== NOT EXECUTED
ffc27008: 4e 80 00 20 blr <== NOT EXECUTED
ffc2700c <rtems_rfs_mutex_destroy>:
int
rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex)
{
ffc2700c: 94 21 ff f0 stwu r1,-16(r1)
ffc27010: 7c 08 02 a6 mflr r0
ffc27014: 90 01 00 14 stw r0,20(r1)
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_delete (*mutex);
ffc27018: 80 63 00 00 lwz r3,0(r3)
return 0;
}
int
rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex)
{
ffc2701c: 93 c1 00 08 stw r30,8(r1)
ffc27020: 93 e1 00 0c stw r31,12(r1)
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_delete (*mutex);
ffc27024: 4b fe 66 8d bl ffc0d6b0 <rtems_semaphore_delete>
if (sc != RTEMS_SUCCESSFUL)
ffc27028: 7c 7e 1b 79 mr. r30,r3
printf ("rtems-rfs: mutex: close failed: %s\n",
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
ffc2702c: 3b e0 00 00 li r31,0
rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_delete (*mutex);
if (sc != RTEMS_SUCCESSFUL)
ffc27030: 40 82 00 20 bne- ffc27050 <rtems_rfs_mutex_destroy+0x44><== NEVER TAKEN
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
ffc27034: 80 01 00 14 lwz r0,20(r1)
ffc27038: 7f e3 fb 78 mr r3,r31
ffc2703c: 83 c1 00 08 lwz r30,8(r1)
ffc27040: 7c 08 03 a6 mtlr r0
ffc27044: 83 e1 00 0c lwz r31,12(r1)
ffc27048: 38 21 00 10 addi r1,r1,16
ffc2704c: 4e 80 00 20 blr
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_delete (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc27050: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc27054: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc27058: 4b ff 09 11 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
printf ("rtems-rfs: mutex: close failed: %s\n",
rtems_status_text (sc));
return EIO;
ffc2705c: 3b e0 00 05 li r31,5 <== NOT EXECUTED
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_delete (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc27060: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc27064: 41 9e ff d0 beq+ cr7,ffc27034 <rtems_rfs_mutex_destroy+0x28><== NOT EXECUTED
printf ("rtems-rfs: mutex: close failed: %s\n",
ffc27068: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc2706c: 4b ff 57 d1 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc27070: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc27074: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc27078: 38 63 dc 8c addi r3,r3,-9076 <== NOT EXECUTED
ffc2707c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc27080: 48 00 3c c5 bl ffc2ad44 <printf> <== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
ffc27084: 80 01 00 14 lwz r0,20(r1) <== NOT EXECUTED
ffc27088: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc2708c: 83 c1 00 08 lwz r30,8(r1) <== NOT EXECUTED
ffc27090: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc27094: 83 e1 00 0c lwz r31,12(r1) <== NOT EXECUTED
ffc27098: 38 21 00 10 addi r1,r1,16 <== NOT EXECUTED
ffc2709c: 4e 80 00 20 blr <== NOT EXECUTED
ffc223e0 <rtems_rfs_release_chain>:
static int
rtems_rfs_release_chain (rtems_chain_control* chain,
uint32_t* count,
bool modified)
{
ffc223e0: 94 21 ff e0 stwu r1,-32(r1)
ffc223e4: 7c 08 02 a6 mflr r0
ffc223e8: 93 c1 00 18 stw r30,24(r1)
ffc223ec: 7c 9e 23 78 mr r30,r4
rtems_rfs_buffer* buffer;
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
ffc223f0: 38 80 00 80 li r4,128
static int
rtems_rfs_release_chain (rtems_chain_control* chain,
uint32_t* count,
bool modified)
{
ffc223f4: 93 e1 00 1c stw r31,28(r1)
ffc223f8: 7c 7f 1b 78 mr r31,r3
rtems_rfs_buffer* buffer;
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
ffc223fc: 38 60 00 00 li r3,0
static int
rtems_rfs_release_chain (rtems_chain_control* chain,
uint32_t* count,
bool modified)
{
ffc22400: 93 41 00 08 stw r26,8(r1)
ffc22404: 7c ba 2b 78 mr r26,r5
ffc22408: 90 01 00 24 stw r0,36(r1)
ffc2240c: 93 61 00 0c stw r27,12(r1)
ffc22410: 93 81 00 10 stw r28,16(r1)
ffc22414: 93 a1 00 14 stw r29,20(r1)
rtems_rfs_buffer* buffer;
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
ffc22418: 4b ff 55 51 bl ffc17968 <rtems_rfs_trace>
ffc2241c: 2f 83 00 00 cmpwi cr7,r3,0
ffc22420: 40 9e 00 8c bne- cr7,ffc224ac <rtems_rfs_release_chain+0xcc><== NEVER TAKEN
(*count)--;
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
ffc22424: 3b a0 00 00 li r29,0
ffc22428: 3b 9f 00 04 addi r28,r31,4
while (!rtems_chain_is_empty (chain))
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (chain);
(*count)--;
buffer->user = (void*) 0;
ffc2242c: 3b 60 00 00 li r27,0
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
while (!rtems_chain_is_empty (chain))
ffc22430: 80 1f 00 00 lwz r0,0(r31)
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
ffc22434: 7f e3 fb 78 mr r3,r31
ffc22438: 7f 80 e0 00 cmpw cr7,r0,r28
ffc2243c: 41 9e 00 44 beq- cr7,ffc22480 <rtems_rfs_release_chain+0xa0>
ffc22440: 4b fe c3 c1 bl ffc0e800 <_Chain_Get>
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (chain);
(*count)--;
ffc22444: 81 7e 00 00 lwz r11,0(r30)
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
ffc22448: 7f 44 d3 78 mr r4,r26
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
while (!rtems_chain_is_empty (chain))
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (chain);
(*count)--;
ffc2244c: 38 0b ff ff addi r0,r11,-1
ffc22450: 90 1e 00 00 stw r0,0(r30)
buffer->user = (void*) 0;
ffc22454: 93 63 00 3c stw r27,60(r3)
rc = rtems_rfs_buffer_io_release (buffer, modified);
ffc22458: 48 00 74 39 bl ffc29890 <rtems_rfs_buffer_bdbuf_release>
if ((rc > 0) && (rrc == 0))
ffc2245c: 2f 9d 00 00 cmpwi cr7,r29,0
ffc22460: 2c 03 00 00 cmpwi r3,0
ffc22464: 40 a1 ff cc ble- ffc22430 <rtems_rfs_release_chain+0x50><== ALWAYS TAKEN
ffc22468: 40 be ff c8 bne- cr7,ffc22430 <rtems_rfs_release_chain+0x50><== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
while (!rtems_chain_is_empty (chain))
ffc2246c: 80 1f 00 00 lwz r0,0(r31) <== NOT EXECUTED
(*count)--;
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
ffc22470: 7c 7d 1b 78 mr r29,r3 <== NOT EXECUTED
ffc22474: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
while (!rtems_chain_is_empty (chain))
ffc22478: 7f 80 e0 00 cmpw cr7,r0,r28 <== NOT EXECUTED
ffc2247c: 40 9e ff c4 bne+ cr7,ffc22440 <rtems_rfs_release_chain+0x60><== NOT EXECUTED
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
rrc = rc;
}
return rrc;
}
ffc22480: 80 01 00 24 lwz r0,36(r1)
ffc22484: 7f a3 eb 78 mr r3,r29
ffc22488: 83 41 00 08 lwz r26,8(r1)
ffc2248c: 7c 08 03 a6 mtlr r0
ffc22490: 83 61 00 0c lwz r27,12(r1)
ffc22494: 83 81 00 10 lwz r28,16(r1)
ffc22498: 83 a1 00 14 lwz r29,20(r1)
ffc2249c: 83 c1 00 18 lwz r30,24(r1)
ffc224a0: 83 e1 00 1c lwz r31,28(r1)
ffc224a4: 38 21 00 20 addi r1,r1,32
ffc224a8: 4e 80 00 20 blr
rtems_rfs_buffer* buffer;
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
ffc224ac: 80 9e 00 00 lwz r4,0(r30) <== NOT EXECUTED
ffc224b0: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc224b4: 38 63 c8 44 addi r3,r3,-14268 <== NOT EXECUTED
ffc224b8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc224bc: 48 00 88 89 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc224c0: 4b ff ff 64 b ffc22424 <rtems_rfs_release_chain+0x44><== NOT EXECUTED
ffc160dc <rtems_rfs_rtems_chown>:
static int
rtems_rfs_rtems_chown (rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
ffc160dc: 94 21 ff b0 stwu r1,-80(r1)
ffc160e0: 7c 08 02 a6 mflr r0
ffc160e4: 7c 69 1b 78 mr r9,r3
ffc160e8: 90 01 00 54 stw r0,84(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc160ec: 81 63 00 10 lwz r11,16(r3)
static int
rtems_rfs_rtems_chown (rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
ffc160f0: 93 e1 00 4c stw r31,76(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc160f4: 83 eb 00 34 lwz r31,52(r11)
static int
rtems_rfs_rtems_chown (rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
ffc160f8: 93 a1 00 44 stw r29,68(r1)
ffc160fc: 7c bd 2b 78 mr r29,r5
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
ffc16100: 38 a0 00 00 li r5,0
rtems_rfs_mutex_destroy (&rtems->access);
free (rtems);
return rtems_rfs_rtems_error ("shutdown: close", rc);
}
ffc16104: 81 7f 00 7c lwz r11,124(r31)
static int
rtems_rfs_rtems_chown (rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
ffc16108: 93 c1 00 48 stw r30,72(r1)
ffc1610c: 7c 9e 23 78 mr r30,r4
ffc16110: 38 80 00 00 li r4,0
ffc16114: 80 6b 00 00 lwz r3,0(r11)
ffc16118: 93 61 00 3c stw r27,60(r1)
ffc1611c: 93 81 00 40 stw r28,64(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
ffc16120: 83 89 00 00 lwz r28,0(r9)
ffc16124: 4b ff 76 69 bl ffc0d78c <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
ffc16128: 7c 7b 1b 79 mr. r27,r3
ffc1612c: 40 82 00 a4 bne- ffc161d0 <rtems_rfs_rtems_chown+0xf4> <== NEVER TAKEN
printf ("rtems-rfs-rtems: chown: in: ino:%" PRId32 " uid:%d gid:%d\n",
ino, owner, group);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc16130: 7f 84 e3 78 mr r4,r28
ffc16134: 7f e3 fb 78 mr r3,r31
ffc16138: 38 a1 00 08 addi r5,r1,8
ffc1613c: 38 c0 00 01 li r6,1
ffc16140: 4b ff de 99 bl ffc13fd8 <rtems_rfs_inode_open>
if (rc > 0)
ffc16144: 7c 7c 1b 79 mr. r28,r3
ffc16148: 40 81 00 d4 ble- ffc1621c <rtems_rfs_rtems_chown+0x140> <== ALWAYS TAKEN
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc1614c: 83 df 00 7c lwz r30,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc16150: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc16154: 48 00 cc 91 bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc16158: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc1615c: 4b ff 77 bd bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc16160: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc16164: 40 82 00 38 bne- ffc1619c <rtems_rfs_rtems_chown+0xc0> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("chown: opening inode", rc);
ffc16168: 48 01 3a f9 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc1616c: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc16170: 93 83 00 00 stw r28,0(r3) <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
ffc16174: 80 01 00 54 lwz r0,84(r1)
ffc16178: 7f e3 fb 78 mr r3,r31
ffc1617c: 83 61 00 3c lwz r27,60(r1)
ffc16180: 7c 08 03 a6 mtlr r0
ffc16184: 83 81 00 40 lwz r28,64(r1)
ffc16188: 83 a1 00 44 lwz r29,68(r1)
ffc1618c: 83 c1 00 48 lwz r30,72(r1)
ffc16190: 83 e1 00 4c lwz r31,76(r1)
ffc16194: 38 21 00 50 addi r1,r1,80
ffc16198: 4e 80 00 20 blr
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc1619c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc161a0: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc161a4: 48 00 17 c5 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc161a8: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc161ac: 41 9e ff bc beq+ cr7,ffc16168 <rtems_rfs_rtems_chown+0x8c><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc161b0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc161b4: 48 00 66 89 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc161b8: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc161bc: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc161c0: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc161c4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc161c8: 48 01 4b 7d bl ffc2ad44 <printf> <== NOT EXECUTED
ffc161cc: 4b ff ff 9c b ffc16168 <rtems_rfs_rtems_chown+0x8c> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc161d0: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc161d4: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc161d8: 48 00 17 91 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc161dc: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc161e0: 41 9e ff 50 beq+ cr7,ffc16130 <rtems_rfs_rtems_chown+0x54><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
ffc161e4: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc161e8: 48 00 66 55 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc161ec: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc161f0: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc161f4: 38 63 bb 30 addi r3,r3,-17616 <== NOT EXECUTED
ffc161f8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc161fc: 48 01 4b 49 bl ffc2ad44 <printf> <== NOT EXECUTED
printf ("rtems-rfs-rtems: chown: in: ino:%" PRId32 " uid:%d gid:%d\n",
ino, owner, group);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc16200: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc16204: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc16208: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
ffc1620c: 38 c0 00 01 li r6,1 <== NOT EXECUTED
ffc16210: 4b ff dd c9 bl ffc13fd8 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
ffc16214: 7c 7c 1b 79 mr. r28,r3 <== NOT EXECUTED
ffc16218: 41 81 ff 34 bgt+ ffc1614c <rtems_rfs_rtems_chown+0x70> <== NOT EXECUTED
/*
* Verify I am the owner of the node or the super user.
*/
#if defined (RTEMS_POSIX_API)
uid = geteuid();
ffc1621c: 48 00 6a 91 bl ffc1ccac <geteuid>
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
ffc16220: 81 21 00 14 lwz r9,20(r1)
* @return uint16_t The user id (uid).
*/
static inline uint16_t
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;
ffc16224: 88 09 00 06 lbz r0,6(r9)
ffc16228: 89 69 00 07 lbz r11,7(r9)
ffc1622c: 54 00 40 2e rlwinm r0,r0,8,0,23
ffc16230: 7c 00 5b 78 or r0,r0,r11
ffc16234: 54 00 04 3e clrlwi r0,r0,16
ffc16238: 7f 83 00 00 cmpw cr7,r3,r0
ffc1623c: 41 9e 00 0c beq- cr7,ffc16248 <rtems_rfs_rtems_chown+0x16c><== ALWAYS TAKEN
ffc16240: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc16244: 40 9e 01 28 bne- cr7,ffc1636c <rtems_rfs_rtems_chown+0x290><== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_uid_gid (rtems_rfs_inode_handle* handle,
uint16_t uid, uint16_t gid)
{
rtems_rfs_write_u32 (&handle->node->owner, (((uint32_t) gid) << 16) | uid);
ffc16248: 57 bd 80 1e rlwinm r29,r29,16,0,15
ffc1624c: 7f bd f3 78 or r29,r29,r30
ffc16250: 57 a0 46 3e rlwinm r0,r29,8,24,31
ffc16254: 98 09 00 04 stb r0,4(r9)
ffc16258: 57 a0 84 3e rlwinm r0,r29,16,16,31
ffc1625c: 57 bd c2 3e rlwinm r29,r29,24,8,31
ffc16260: 81 21 00 14 lwz r9,20(r1)
}
#endif
rtems_rfs_inode_set_uid_gid (&inode, owner, group);
rc = rtems_rfs_inode_close (fs, &inode);
ffc16264: 7f e3 fb 78 mr r3,r31
ffc16268: 38 81 00 08 addi r4,r1,8
ffc1626c: 98 09 00 05 stb r0,5(r9)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc16270: 38 00 00 01 li r0,1
*/
static inline void
rtems_rfs_inode_set_uid_gid (rtems_rfs_inode_handle* handle,
uint16_t uid, uint16_t gid)
{
rtems_rfs_write_u32 (&handle->node->owner, (((uint32_t) gid) << 16) | uid);
ffc16274: 81 21 00 14 lwz r9,20(r1)
ffc16278: 9b a9 00 06 stb r29,6(r9)
ffc1627c: 81 21 00 14 lwz r9,20(r1)
ffc16280: 9b c9 00 07 stb r30,7(r9)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc16284: 98 01 00 18 stb r0,24(r1)
ffc16288: 4b ff df b1 bl ffc14238 <rtems_rfs_inode_close>
if (rc)
ffc1628c: 7c 7e 1b 79 mr. r30,r3
ffc16290: 41 82 00 54 beq- ffc162e4 <rtems_rfs_rtems_chown+0x208> <== ALWAYS TAKEN
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc16294: 83 bf 00 7c lwz r29,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc16298: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1629c: 48 00 cb 49 bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc162a0: 80 7d 00 00 lwz r3,0(r29) <== NOT EXECUTED
ffc162a4: 4b ff 76 75 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc162a8: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc162ac: 40 82 00 8c bne- ffc16338 <rtems_rfs_rtems_chown+0x25c> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("chown: closing inode", rc);
ffc162b0: 48 01 39 b1 bl ffc29c60 <__errno> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
ffc162b4: 80 01 00 54 lwz r0,84(r1) <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
if (rc)
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("chown: closing inode", rc);
ffc162b8: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc162bc: 93 c3 00 00 stw r30,0(r3) <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
ffc162c0: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc162c4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc162c8: 83 61 00 3c lwz r27,60(r1) <== NOT EXECUTED
ffc162cc: 83 81 00 40 lwz r28,64(r1) <== NOT EXECUTED
ffc162d0: 83 a1 00 44 lwz r29,68(r1) <== NOT EXECUTED
ffc162d4: 83 c1 00 48 lwz r30,72(r1) <== NOT EXECUTED
ffc162d8: 83 e1 00 4c lwz r31,76(r1) <== NOT EXECUTED
ffc162dc: 38 21 00 50 addi r1,r1,80 <== NOT EXECUTED
ffc162e0: 4e 80 00 20 blr <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc162e4: 83 df 00 7c lwz r30,124(r31)
rtems_rfs_buffers_release (fs);
ffc162e8: 7f e3 fb 78 mr r3,r31
ffc162ec: 48 00 ca f9 bl ffc22de4 <rtems_rfs_buffers_release>
return rtems_rfs_rtems_error ("chown: closing inode", rc);
}
rtems_rfs_rtems_unlock (fs);
return 0;
ffc162f0: 3b e0 00 00 li r31,0
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc162f4: 80 7e 00 00 lwz r3,0(r30)
ffc162f8: 4b ff 76 21 bl ffc0d918 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc162fc: 7c 7e 1b 79 mr. r30,r3
ffc16300: 41 82 fe 74 beq+ ffc16174 <rtems_rfs_rtems_chown+0x98> <== ALWAYS TAKEN
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc16304: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc16308: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc1630c: 48 00 16 5d bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc16310: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc16314: 41 9e fe 60 beq+ cr7,ffc16174 <rtems_rfs_rtems_chown+0x98><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc16318: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1631c: 48 00 65 21 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc16320: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc16324: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc16328: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc1632c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc16330: 48 01 4a 15 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc16334: 4b ff fe 40 b ffc16174 <rtems_rfs_rtems_chown+0x98> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc16338: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1633c: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc16340: 48 00 16 29 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc16344: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc16348: 41 9e ff 68 beq+ cr7,ffc162b0 <rtems_rfs_rtems_chown+0x1d4><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc1634c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc16350: 48 00 64 ed bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc16354: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc16358: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc1635c: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc16360: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc16364: 48 01 49 e1 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc16368: 4b ff ff 48 b ffc162b0 <rtems_rfs_rtems_chown+0x1d4> <== NOT EXECUTED
#if defined (RTEMS_POSIX_API)
uid = geteuid();
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
{
rtems_rfs_inode_close (fs, &inode);
ffc1636c: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc16370: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc16374: 4b ff de c5 bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc16378: 83 df 00 7c lwz r30,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc1637c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc16380: 48 00 ca 65 bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc16384: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc16388: 4b ff 75 91 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc1638c: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc16390: 40 82 00 18 bne- ffc163a8 <rtems_rfs_rtems_chown+0x2cc> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("chown: not able", EPERM);
ffc16394: 48 01 38 cd bl ffc29c60 <__errno> <== NOT EXECUTED
ffc16398: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc1639c: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc163a0: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc163a4: 4b ff fd d0 b ffc16174 <rtems_rfs_rtems_chown+0x98> <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc163a8: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc163ac: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc163b0: 48 00 15 b9 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc163b4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc163b8: 41 9e ff dc beq+ cr7,ffc16394 <rtems_rfs_rtems_chown+0x2b8><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc163bc: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc163c0: 48 00 64 7d bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc163c4: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc163c8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc163cc: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc163d0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc163d4: 48 01 49 71 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc163d8: 4b ff ff bc b ffc16394 <rtems_rfs_rtems_chown+0x2b8> <== NOT EXECUTED
ffc27238 <rtems_rfs_rtems_device_close>:
* @return int
*/
static int
rtems_rfs_rtems_device_close (rtems_libio_t* iop)
{
ffc27238: 94 21 ff e8 stwu r1,-24(r1) <== NOT EXECUTED
ffc2723c: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc27240: 7c 69 1b 78 mr r9,r3 <== NOT EXECUTED
ffc27244: 90 01 00 1c stw r0,28(r1) <== NOT EXECUTED
args.iop = iop;
args.flags = 0;
args.mode = 0;
status = rtems_io_close (major, minor, (void *) &args);
ffc27248: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
args.flags = 0;
ffc2724c: 38 00 00 00 li r0,0 <== NOT EXECUTED
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
ffc27250: 80 89 00 38 lwz r4,56(r9) <== NOT EXECUTED
rtems_libio_open_close_args_t args;
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
ffc27254: 80 63 00 34 lwz r3,52(r3) <== NOT EXECUTED
minor = (intptr_t) iop->data1;
args.iop = iop;
args.flags = 0;
ffc27258: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
args.mode = 0;
ffc2725c: 90 01 00 10 stw r0,16(r1) <== NOT EXECUTED
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
ffc27260: 91 21 00 08 stw r9,8(r1) <== NOT EXECUTED
args.flags = 0;
args.mode = 0;
status = rtems_io_close (major, minor, (void *) &args);
ffc27264: 48 00 21 f1 bl ffc29454 <rtems_io_close> <== NOT EXECUTED
return rtems_deviceio_errno (status);
ffc27268: 48 00 14 e5 bl ffc2874c <rtems_deviceio_errno> <== NOT EXECUTED
}
ffc2726c: 80 01 00 1c lwz r0,28(r1) <== NOT EXECUTED
ffc27270: 38 21 00 18 addi r1,r1,24 <== NOT EXECUTED
ffc27274: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc27278: 4e 80 00 20 blr <== NOT EXECUTED
ffc270ac <rtems_rfs_rtems_device_ftruncate>:
static int
rtems_rfs_rtems_device_ftruncate (rtems_libio_t* iop, rtems_off64_t length)
{
return 0;
}
ffc270ac: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc270b0: 4e 80 00 20 blr <== NOT EXECUTED
ffc270b4 <rtems_rfs_rtems_device_ioctl>:
static int
rtems_rfs_rtems_device_ioctl (rtems_libio_t* iop,
uint32_t command,
void* buffer)
{
ffc270b4: 94 21 ff e8 stwu r1,-24(r1) <== NOT EXECUTED
ffc270b8: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc270bc: 7c 69 1b 78 mr r9,r3 <== NOT EXECUTED
ffc270c0: 90 01 00 1c stw r0,28(r1) <== NOT EXECUTED
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
ffc270c4: 80 09 00 38 lwz r0,56(r9) <== NOT EXECUTED
rtems_libio_ioctl_args_t args;
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
ffc270c8: 80 63 00 34 lwz r3,52(r3) <== NOT EXECUTED
minor = (intptr_t) iop->data1;
args.iop = iop;
args.command = command;
ffc270cc: 90 81 00 0c stw r4,12(r1) <== NOT EXECUTED
args.buffer = buffer;
status = rtems_io_control (major, minor, (void *) &args);
ffc270d0: 7c 04 03 78 mr r4,r0 <== NOT EXECUTED
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
args.command = command;
args.buffer = buffer;
ffc270d4: 90 a1 00 10 stw r5,16(r1) <== NOT EXECUTED
status = rtems_io_control (major, minor, (void *) &args);
ffc270d8: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
ffc270dc: 91 21 00 08 stw r9,8(r1) <== NOT EXECUTED
args.command = command;
args.buffer = buffer;
status = rtems_io_control (major, minor, (void *) &args);
ffc270e0: 48 00 23 e9 bl ffc294c8 <rtems_io_control> <== NOT EXECUTED
if (status)
ffc270e4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
return rtems_deviceio_errno (status);
return args.ioctl_return;
ffc270e8: 80 01 00 14 lwz r0,20(r1) <== NOT EXECUTED
args.iop = iop;
args.command = command;
args.buffer = buffer;
status = rtems_io_control (major, minor, (void *) &args);
if (status)
ffc270ec: 40 9e 00 18 bne- cr7,ffc27104 <rtems_rfs_rtems_device_ioctl+0x50><== NOT EXECUTED
return rtems_deviceio_errno (status);
return args.ioctl_return;
}
ffc270f0: 7c 03 03 78 mr r3,r0 <== NOT EXECUTED
ffc270f4: 80 01 00 1c lwz r0,28(r1) <== NOT EXECUTED
ffc270f8: 38 21 00 18 addi r1,r1,24 <== NOT EXECUTED
ffc270fc: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc27100: 4e 80 00 20 blr <== NOT EXECUTED
args.command = command;
args.buffer = buffer;
status = rtems_io_control (major, minor, (void *) &args);
if (status)
return rtems_deviceio_errno (status);
ffc27104: 48 00 16 49 bl ffc2874c <rtems_deviceio_errno> <== NOT EXECUTED
ffc27108: 7c 60 1b 78 mr r0,r3 <== NOT EXECUTED
return args.ioctl_return;
}
ffc2710c: 7c 03 03 78 mr r3,r0 <== NOT EXECUTED
ffc27110: 80 01 00 1c lwz r0,28(r1) <== NOT EXECUTED
ffc27114: 38 21 00 18 addi r1,r1,24 <== NOT EXECUTED
ffc27118: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc2711c: 4e 80 00 20 blr <== NOT EXECUTED
ffc270a0 <rtems_rfs_rtems_device_lseek>:
rtems_rfs_rtems_device_lseek (rtems_libio_t* iop,
rtems_off64_t offset,
int whence)
{
return offset;
}
ffc270a0: 7c a3 2b 78 mr r3,r5 <== NOT EXECUTED
ffc270a4: 7c c4 33 78 mr r4,r6 <== NOT EXECUTED
ffc270a8: 4e 80 00 20 blr <== NOT EXECUTED
ffc2727c <rtems_rfs_rtems_device_open>:
static int
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode)
{
ffc2727c: 94 21 ff 88 stwu r1,-120(r1) <== NOT EXECUTED
ffc27280: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
ffc27284: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc27288: 90 01 00 7c stw r0,124(r1) <== NOT EXECUTED
ffc2728c: 38 a0 00 00 li r5,0 <== NOT EXECUTED
rtems_libio_open_close_args_t args;
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
ffc27290: 81 23 00 2c lwz r9,44(r3) <== NOT EXECUTED
static int
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode)
{
ffc27294: 93 e1 00 74 stw r31,116(r1) <== NOT EXECUTED
rtems_libio_open_close_args_t args;
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
ffc27298: 83 e9 00 34 lwz r31,52(r9) <== NOT EXECUTED
static int
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode)
{
ffc2729c: 93 c1 00 70 stw r30,112(r1) <== NOT EXECUTED
ffc272a0: 7c 7e 1b 78 mr r30,r3 <== NOT EXECUTED
.fpathconf_h = rtems_filesystem_default_fpathconf,
.fsync_h = rtems_filesystem_default_fsync,
.fdatasync_h = rtems_filesystem_default_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl,
.rmnod_h = rtems_rfs_rtems_rmnod
};
ffc272a4: 81 3f 00 7c lwz r9,124(r31) <== NOT EXECUTED
static int
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode)
{
ffc272a8: 93 61 00 64 stw r27,100(r1) <== NOT EXECUTED
ffc272ac: 80 69 00 00 lwz r3,0(r9) <== NOT EXECUTED
ffc272b0: 93 81 00 68 stw r28,104(r1) <== NOT EXECUTED
ffc272b4: 93 a1 00 6c stw r29,108(r1) <== NOT EXECUTED
ffc272b8: 7c dd 33 78 mr r29,r6 <== NOT EXECUTED
ffc272bc: 92 81 00 48 stw r20,72(r1) <== NOT EXECUTED
ffc272c0: 92 a1 00 4c stw r21,76(r1) <== NOT EXECUTED
ffc272c4: 92 c1 00 50 stw r22,80(r1) <== NOT EXECUTED
ffc272c8: 92 e1 00 54 stw r23,84(r1) <== NOT EXECUTED
ffc272cc: 93 01 00 58 stw r24,88(r1) <== NOT EXECUTED
ffc272d0: 93 21 00 5c stw r25,92(r1) <== NOT EXECUTED
ffc272d4: 93 41 00 60 stw r26,96(r1) <== NOT EXECUTED
rtems_libio_open_close_args_t args;
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
ffc272d8: 83 9e 00 1c lwz r28,28(r30) <== NOT EXECUTED
ffc272dc: 4b fe 64 b1 bl ffc0d78c <rtems_semaphore_obtain> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc272e0: 7c 7b 1b 79 mr. r27,r3 <== NOT EXECUTED
ffc272e4: 40 82 00 bc bne- ffc273a0 <rtems_rfs_rtems_device_open+0x124><== NOT EXECUTED
rtems_status_code status;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc272e8: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc272ec: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc272f0: 38 a1 00 14 addi r5,r1,20 <== NOT EXECUTED
ffc272f4: 38 c0 00 01 li r6,1 <== NOT EXECUTED
ffc272f8: 4b fe cc e1 bl ffc13fd8 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
ffc272fc: 7c 7c 1b 79 mr. r28,r3 <== NOT EXECUTED
ffc27300: 40 81 00 d4 ble- ffc273d4 <rtems_rfs_rtems_device_open+0x158><== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc27304: 83 df 00 7c lwz r30,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc27308: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc2730c: 4b ff ba d9 bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc27310: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc27314: 4b fe 66 05 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc27318: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc2731c: 40 82 00 50 bne- ffc2736c <rtems_rfs_rtems_device_open+0xf0><== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
ffc27320: 48 00 29 41 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc27324: 93 83 00 00 stw r28,0(r3) <== NOT EXECUTED
ffc27328: 38 60 ff ff li r3,-1 <== NOT EXECUTED
args.mode = mode;
status = rtems_io_open (major, minor, (void *) &args);
return rtems_deviceio_errno (status);
}
ffc2732c: 80 01 00 7c lwz r0,124(r1) <== NOT EXECUTED
ffc27330: 82 81 00 48 lwz r20,72(r1) <== NOT EXECUTED
ffc27334: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc27338: 82 a1 00 4c lwz r21,76(r1) <== NOT EXECUTED
ffc2733c: 82 c1 00 50 lwz r22,80(r1) <== NOT EXECUTED
ffc27340: 82 e1 00 54 lwz r23,84(r1) <== NOT EXECUTED
ffc27344: 83 01 00 58 lwz r24,88(r1) <== NOT EXECUTED
ffc27348: 83 21 00 5c lwz r25,92(r1) <== NOT EXECUTED
ffc2734c: 83 41 00 60 lwz r26,96(r1) <== NOT EXECUTED
ffc27350: 83 61 00 64 lwz r27,100(r1) <== NOT EXECUTED
ffc27354: 83 81 00 68 lwz r28,104(r1) <== NOT EXECUTED
ffc27358: 83 a1 00 6c lwz r29,108(r1) <== NOT EXECUTED
ffc2735c: 83 c1 00 70 lwz r30,112(r1) <== NOT EXECUTED
ffc27360: 83 e1 00 74 lwz r31,116(r1) <== NOT EXECUTED
ffc27364: 38 21 00 78 addi r1,r1,120 <== NOT EXECUTED
ffc27368: 4e 80 00 20 blr <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc2736c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc27370: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc27374: 4b ff 05 f5 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc27378: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc2737c: 41 9e ff a4 beq+ cr7,ffc27320 <rtems_rfs_rtems_device_open+0xa4><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc27380: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc27384: 4b ff 54 b9 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc27388: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc2738c: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc27390: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc27394: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc27398: 48 00 39 ad bl ffc2ad44 <printf> <== NOT EXECUTED
ffc2739c: 4b ff ff 84 b ffc27320 <rtems_rfs_rtems_device_open+0xa4><== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc273a0: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc273a4: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc273a8: 4b ff 05 c1 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc273ac: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc273b0: 41 9e ff 38 beq+ cr7,ffc272e8 <rtems_rfs_rtems_device_open+0x6c><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
ffc273b4: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc273b8: 4b ff 54 85 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc273bc: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc273c0: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc273c4: 38 63 bb 30 addi r3,r3,-17616 <== NOT EXECUTED
ffc273c8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc273cc: 48 00 39 79 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc273d0: 4b ff ff 18 b ffc272e8 <rtems_rfs_rtems_device_open+0x6c><== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("device_open: opening inode", rc);
}
major = rtems_rfs_inode_get_block (&inode, 0);
ffc273d4: 81 21 00 20 lwz r9,32(r1) <== NOT EXECUTED
minor = rtems_rfs_inode_get_block (&inode, 1);
rc = rtems_rfs_inode_close (fs, &inode);
ffc273d8: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc273dc: 38 81 00 14 addi r4,r1,20 <== NOT EXECUTED
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
ffc273e0: 8a 89 00 1c lbz r20,28(r9) <== NOT EXECUTED
ffc273e4: 8a a9 00 1d lbz r21,29(r9) <== NOT EXECUTED
ffc273e8: 8b 49 00 1e lbz r26,30(r9) <== NOT EXECUTED
ffc273ec: 8b 09 00 1f lbz r24,31(r9) <== NOT EXECUTED
ffc273f0: 8a c9 00 20 lbz r22,32(r9) <== NOT EXECUTED
ffc273f4: 8a e9 00 21 lbz r23,33(r9) <== NOT EXECUTED
ffc273f8: 8b 69 00 22 lbz r27,34(r9) <== NOT EXECUTED
ffc273fc: 8b 29 00 23 lbz r25,35(r9) <== NOT EXECUTED
ffc27400: 4b fe ce 39 bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
ffc27404: 7c 7c 1b 79 mr. r28,r3 <== NOT EXECUTED
ffc27408: 41 81 fe fc bgt+ ffc27304 <rtems_rfs_rtems_device_open+0x88><== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc2740c: 83 9f 00 7c lwz r28,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc27410: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc27414: 4b ff b9 d1 bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc27418: 80 7c 00 00 lwz r3,0(r28) <== NOT EXECUTED
ffc2741c: 4b fe 64 fd bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc27420: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc27424: 40 82 00 60 bne- ffc27484 <rtems_rfs_rtems_device_open+0x208><== NOT EXECUTED
ffc27428: 56 83 c0 0e rlwinm r3,r20,24,0,7 <== NOT EXECUTED
iop->data0 = major;
iop->data1 = (void*)((intptr_t) minor);
args.iop = iop;
args.flags = iop->flags;
ffc2742c: 80 1e 00 18 lwz r0,24(r30) <== NOT EXECUTED
ffc27430: 56 b5 80 1e rlwinm r21,r21,16,0,15 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
iop->data0 = major;
iop->data1 = (void*)((intptr_t) minor);
args.iop = iop;
ffc27434: 93 c1 00 08 stw r30,8(r1) <== NOT EXECUTED
ffc27438: 56 d6 c0 0e rlwinm r22,r22,24,0,7 <== NOT EXECUTED
ffc2743c: 56 f7 80 1e rlwinm r23,r23,16,0,15 <== NOT EXECUTED
args.flags = iop->flags;
ffc27440: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
ffc27444: 7c 63 ab 78 or r3,r3,r21 <== NOT EXECUTED
ffc27448: 7e d7 bb 78 or r23,r22,r23 <== NOT EXECUTED
args.mode = mode;
ffc2744c: 93 a1 00 10 stw r29,16(r1) <== NOT EXECUTED
ffc27450: 7c 78 c3 78 or r24,r3,r24 <== NOT EXECUTED
ffc27454: 7e f9 cb 78 or r25,r23,r25 <== NOT EXECUTED
ffc27458: 57 5a 40 2e rlwinm r26,r26,8,0,23 <== NOT EXECUTED
ffc2745c: 57 7b 40 2e rlwinm r27,r27,8,0,23 <== NOT EXECUTED
ffc27460: 7f 3b db 78 or r27,r25,r27 <== NOT EXECUTED
ffc27464: 7f 03 d3 78 or r3,r24,r26 <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
iop->data0 = major;
iop->data1 = (void*)((intptr_t) minor);
ffc27468: 93 7e 00 38 stw r27,56(r30) <== NOT EXECUTED
args.iop = iop;
args.flags = iop->flags;
args.mode = mode;
status = rtems_io_open (major, minor, (void *) &args);
ffc2746c: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
}
rtems_rfs_rtems_unlock (fs);
iop->data0 = major;
ffc27470: 90 7e 00 34 stw r3,52(r30) <== NOT EXECUTED
args.iop = iop;
args.flags = iop->flags;
args.mode = mode;
status = rtems_io_open (major, minor, (void *) &args);
ffc27474: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
ffc27478: 48 00 20 c5 bl ffc2953c <rtems_io_open> <== NOT EXECUTED
return rtems_deviceio_errno (status);
ffc2747c: 48 00 12 d1 bl ffc2874c <rtems_deviceio_errno> <== NOT EXECUTED
ffc27480: 4b ff fe ac b ffc2732c <rtems_rfs_rtems_device_open+0xb0><== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc27484: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc27488: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc2748c: 4b ff 04 dd bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc27490: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc27494: 41 9e ff 94 beq+ cr7,ffc27428 <rtems_rfs_rtems_device_open+0x1ac><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc27498: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc2749c: 4b ff 53 a1 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc274a0: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc274a4: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc274a8: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc274ac: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc274b0: 48 00 38 95 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc274b4: 4b ff ff 74 b ffc27428 <rtems_rfs_rtems_device_open+0x1ac><== NOT EXECUTED
ffc271ac <rtems_rfs_rtems_device_read>:
* @return ssize_t
*/
static ssize_t
rtems_rfs_rtems_device_read (rtems_libio_t* iop, void* buffer, size_t count)
{
ffc271ac: 94 21 ff d8 stwu r1,-40(r1) <== NOT EXECUTED
ffc271b0: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc271b4: 7c 69 1b 78 mr r9,r3 <== NOT EXECUTED
ffc271b8: 90 01 00 2c stw r0,44(r1) <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
ffc271bc: 80 09 00 18 lwz r0,24(r9) <== NOT EXECUTED
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
ffc271c0: 81 09 00 38 lwz r8,56(r9) <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
ffc271c4: 81 49 00 10 lwz r10,16(r9) <== NOT EXECUTED
ffc271c8: 81 69 00 14 lwz r11,20(r9) <== NOT EXECUTED
rtems_libio_rw_args_t args;
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
ffc271cc: 80 63 00 34 lwz r3,52(r3) <== NOT EXECUTED
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
ffc271d0: 90 81 00 18 stw r4,24(r1) <== NOT EXECUTED
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read (major, minor, (void *) &args);
ffc271d4: 7d 04 43 78 mr r4,r8 <== NOT EXECUTED
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
ffc271d8: 90 a1 00 1c stw r5,28(r1) <== NOT EXECUTED
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read (major, minor, (void *) &args);
ffc271dc: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
ffc271e0: 90 01 00 20 stw r0,32(r1) <== NOT EXECUTED
args.bytes_moved = 0;
ffc271e4: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc271e8: 90 01 00 24 stw r0,36(r1) <== NOT EXECUTED
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
ffc271ec: 91 21 00 08 stw r9,8(r1) <== NOT EXECUTED
args.offset = iop->offset;
ffc271f0: 91 41 00 10 stw r10,16(r1) <== NOT EXECUTED
ffc271f4: 91 61 00 14 stw r11,20(r1) <== NOT EXECUTED
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read (major, minor, (void *) &args);
ffc271f8: 48 00 23 b9 bl ffc295b0 <rtems_io_read> <== NOT EXECUTED
if (status)
ffc271fc: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
return rtems_deviceio_errno (status);
return (ssize_t) args.bytes_moved;
ffc27200: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read (major, minor, (void *) &args);
if (status)
ffc27204: 40 9e 00 18 bne- cr7,ffc2721c <rtems_rfs_rtems_device_read+0x70><== NOT EXECUTED
return rtems_deviceio_errno (status);
return (ssize_t) args.bytes_moved;
}
ffc27208: 7c 03 03 78 mr r3,r0 <== NOT EXECUTED
ffc2720c: 80 01 00 2c lwz r0,44(r1) <== NOT EXECUTED
ffc27210: 38 21 00 28 addi r1,r1,40 <== NOT EXECUTED
ffc27214: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc27218: 4e 80 00 20 blr <== NOT EXECUTED
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read (major, minor, (void *) &args);
if (status)
return rtems_deviceio_errno (status);
ffc2721c: 48 00 15 31 bl ffc2874c <rtems_deviceio_errno> <== NOT EXECUTED
ffc27220: 7c 60 1b 78 mr r0,r3 <== NOT EXECUTED
return (ssize_t) args.bytes_moved;
}
ffc27224: 7c 03 03 78 mr r3,r0 <== NOT EXECUTED
ffc27228: 80 01 00 2c lwz r0,44(r1) <== NOT EXECUTED
ffc2722c: 38 21 00 28 addi r1,r1,40 <== NOT EXECUTED
ffc27230: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc27234: 4e 80 00 20 blr <== NOT EXECUTED
ffc27120 <rtems_rfs_rtems_device_write>:
static ssize_t
rtems_rfs_rtems_device_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
ffc27120: 94 21 ff d8 stwu r1,-40(r1) <== NOT EXECUTED
ffc27124: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc27128: 7c 69 1b 78 mr r9,r3 <== NOT EXECUTED
ffc2712c: 90 01 00 2c stw r0,44(r1) <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
ffc27130: 80 09 00 18 lwz r0,24(r9) <== NOT EXECUTED
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
ffc27134: 81 09 00 38 lwz r8,56(r9) <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
ffc27138: 81 49 00 10 lwz r10,16(r9) <== NOT EXECUTED
ffc2713c: 81 69 00 14 lwz r11,20(r9) <== NOT EXECUTED
rtems_libio_rw_args_t args;
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
ffc27140: 80 63 00 34 lwz r3,52(r3) <== NOT EXECUTED
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
ffc27144: 90 81 00 18 stw r4,24(r1) <== NOT EXECUTED
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_write (major, minor, (void *) &args);
ffc27148: 7d 04 43 78 mr r4,r8 <== NOT EXECUTED
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
args.count = count;
ffc2714c: 90 a1 00 1c stw r5,28(r1) <== NOT EXECUTED
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_write (major, minor, (void *) &args);
ffc27150: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
ffc27154: 90 01 00 20 stw r0,32(r1) <== NOT EXECUTED
args.bytes_moved = 0;
ffc27158: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc2715c: 90 01 00 24 stw r0,36(r1) <== NOT EXECUTED
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
ffc27160: 91 21 00 08 stw r9,8(r1) <== NOT EXECUTED
args.offset = iop->offset;
ffc27164: 91 41 00 10 stw r10,16(r1) <== NOT EXECUTED
ffc27168: 91 61 00 14 stw r11,20(r1) <== NOT EXECUTED
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_write (major, minor, (void *) &args);
ffc2716c: 48 00 24 b9 bl ffc29624 <rtems_io_write> <== NOT EXECUTED
if (status)
ffc27170: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
return rtems_deviceio_errno (status);
return (ssize_t) args.bytes_moved;
ffc27174: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_write (major, minor, (void *) &args);
if (status)
ffc27178: 40 9e 00 18 bne- cr7,ffc27190 <rtems_rfs_rtems_device_write+0x70><== NOT EXECUTED
return rtems_deviceio_errno (status);
return (ssize_t) args.bytes_moved;
}
ffc2717c: 7c 03 03 78 mr r3,r0 <== NOT EXECUTED
ffc27180: 80 01 00 2c lwz r0,44(r1) <== NOT EXECUTED
ffc27184: 38 21 00 28 addi r1,r1,40 <== NOT EXECUTED
ffc27188: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc2718c: 4e 80 00 20 blr <== NOT EXECUTED
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_write (major, minor, (void *) &args);
if (status)
return rtems_deviceio_errno (status);
ffc27190: 48 00 15 bd bl ffc2874c <rtems_deviceio_errno> <== NOT EXECUTED
ffc27194: 7c 60 1b 78 mr r0,r3 <== NOT EXECUTED
return (ssize_t) args.bytes_moved;
}
ffc27198: 7c 03 03 78 mr r3,r0 <== NOT EXECUTED
ffc2719c: 80 01 00 2c lwz r0,44(r1) <== NOT EXECUTED
ffc271a0: 38 21 00 28 addi r1,r1,40 <== NOT EXECUTED
ffc271a4: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc271a8: 4e 80 00 20 blr <== NOT EXECUTED
ffc274c0 <rtems_rfs_rtems_dir_lseek>:
static rtems_off64_t
rtems_rfs_rtems_dir_lseek (rtems_libio_t* iop,
rtems_off64_t offset,
int whence)
{
switch (whence)
ffc274c0: 2b 87 00 01 cmplwi cr7,r7,1 <== NOT EXECUTED
*/
static rtems_off64_t
rtems_rfs_rtems_dir_lseek (rtems_libio_t* iop,
rtems_off64_t offset,
int whence)
{
ffc274c4: 94 21 ff f8 stwu r1,-8(r1) <== NOT EXECUTED
ffc274c8: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
/* is not a permitted operation */
default:
return rtems_rfs_rtems_error ("dir_lseek: bad whence", EINVAL);
break;
}
return 0;
ffc274cc: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc274d0: 38 80 00 00 li r4,0 <== NOT EXECUTED
*/
static rtems_off64_t
rtems_rfs_rtems_dir_lseek (rtems_libio_t* iop,
rtems_off64_t offset,
int whence)
{
ffc274d4: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
switch (whence)
ffc274d8: 40 9d 00 18 ble- cr7,ffc274f0 <rtems_rfs_rtems_dir_lseek+0x30><== NOT EXECUTED
break;
case SEEK_END: /* Movement past the end of the directory via lseek */
/* is not a permitted operation */
default:
return rtems_rfs_rtems_error ("dir_lseek: bad whence", EINVAL);
ffc274dc: 48 00 27 85 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc274e0: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc274e4: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc274e8: 38 80 ff ff li r4,-1 <== NOT EXECUTED
ffc274ec: 38 60 ff ff li r3,-1 <== NOT EXECUTED
break;
}
return 0;
}
ffc274f0: 80 01 00 0c lwz r0,12(r1) <== NOT EXECUTED
ffc274f4: 38 21 00 08 addi r1,r1,8 <== NOT EXECUTED
ffc274f8: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc274fc: 4e 80 00 20 blr <== NOT EXECUTED
ffc279ac <rtems_rfs_rtems_dir_open>:
static int
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
uint32_t flag,
uint32_t mode)
{
ffc279ac: 94 21 ff b8 stwu r1,-72(r1)
ffc279b0: 7c 08 02 a6 mflr r0
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
ffc279b4: 38 80 00 00 li r4,0
ffc279b8: 90 01 00 4c stw r0,76(r1)
ffc279bc: 38 a0 00 00 li r5,0
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
ffc279c0: 81 23 00 2c lwz r9,44(r3)
static int
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
uint32_t flag,
uint32_t mode)
{
ffc279c4: 93 e1 00 44 stw r31,68(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
ffc279c8: 83 e9 00 34 lwz r31,52(r9)
static int
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
uint32_t flag,
uint32_t mode)
{
ffc279cc: 93 a1 00 3c stw r29,60(r1)
.fpathconf_h = rtems_filesystem_default_fpathconf,
.fsync_h = rtems_filesystem_default_fsync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl,
.rmnod_h = rtems_rfs_rtems_dir_rmnod
};
ffc279d0: 81 3f 00 7c lwz r9,124(r31)
static int
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
uint32_t flag,
uint32_t mode)
{
ffc279d4: 93 c1 00 40 stw r30,64(r1)
ffc279d8: 7c 7e 1b 78 mr r30,r3
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
ffc279dc: 83 a3 00 1c lwz r29,28(r3)
ffc279e0: 80 69 00 00 lwz r3,0(r9)
static int
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
uint32_t flag,
uint32_t mode)
{
ffc279e4: 93 81 00 38 stw r28,56(r1)
ffc279e8: 4b fe 5d a5 bl ffc0d78c <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
ffc279ec: 7c 7c 1b 79 mr. r28,r3
ffc279f0: 40 82 00 c8 bne- ffc27ab8 <rtems_rfs_rtems_dir_open+0x10c><== NEVER TAKEN
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc279f4: 7f a4 eb 78 mr r4,r29
ffc279f8: 7f e3 fb 78 mr r3,r31
ffc279fc: 38 a1 00 08 addi r5,r1,8
ffc27a00: 38 c0 00 01 li r6,1
ffc27a04: 4b fe c5 d5 bl ffc13fd8 <rtems_rfs_inode_open>
if (rc)
ffc27a08: 7c 7d 1b 79 mr. r29,r3
ffc27a0c: 40 82 00 f8 bne- ffc27b04 <rtems_rfs_rtems_dir_open+0x158><== NEVER TAKEN
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_open: opening inode", rc);
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
ffc27a10: 81 21 00 14 lwz r9,20(r1)
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
ffc27a14: 88 09 00 02 lbz r0,2(r9)
ffc27a18: 54 00 44 26 rlwinm r0,r0,8,16,19
ffc27a1c: 2f 80 40 00 cmpwi cr7,r0,16384
ffc27a20: 40 9e 01 64 bne- cr7,ffc27b84 <rtems_rfs_rtems_dir_open+0x1d8><== NEVER TAKEN
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);
}
iop->offset = 0;
ffc27a24: 39 40 00 00 li r10,0
ffc27a28: 39 60 00 00 li r11,0
ffc27a2c: 91 5e 00 10 stw r10,16(r30)
rtems_rfs_inode_close (fs, &inode);
ffc27a30: 38 81 00 08 addi r4,r1,8
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);
}
iop->offset = 0;
ffc27a34: 91 7e 00 14 stw r11,20(r30)
rtems_rfs_inode_close (fs, &inode);
ffc27a38: 7f e3 fb 78 mr r3,r31
ffc27a3c: 4b fe c7 fd bl ffc14238 <rtems_rfs_inode_close>
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc27a40: 83 df 00 7c lwz r30,124(r31)
rtems_rfs_buffers_release (fs);
ffc27a44: 7f e3 fb 78 mr r3,r31
ffc27a48: 4b ff b3 9d bl ffc22de4 <rtems_rfs_buffers_release>
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc27a4c: 80 7e 00 00 lwz r3,0(r30)
rtems_rfs_rtems_unlock (fs);
return 0;
ffc27a50: 3b e0 00 00 li r31,0
ffc27a54: 4b fe 5e c5 bl ffc0d918 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc27a58: 7c 7e 1b 79 mr. r30,r3
ffc27a5c: 40 82 00 28 bne- ffc27a84 <rtems_rfs_rtems_dir_open+0xd8><== NEVER TAKEN
}
ffc27a60: 80 01 00 4c lwz r0,76(r1)
ffc27a64: 7f e3 fb 78 mr r3,r31
ffc27a68: 83 81 00 38 lwz r28,56(r1)
ffc27a6c: 7c 08 03 a6 mtlr r0
ffc27a70: 83 a1 00 3c lwz r29,60(r1)
ffc27a74: 83 c1 00 40 lwz r30,64(r1)
ffc27a78: 83 e1 00 44 lwz r31,68(r1)
ffc27a7c: 38 21 00 48 addi r1,r1,72
ffc27a80: 4e 80 00 20 blr
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc27a84: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc27a88: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc27a8c: 4b fe fe dd bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc27a90: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc27a94: 41 9e ff cc beq+ cr7,ffc27a60 <rtems_rfs_rtems_dir_open+0xb4><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc27a98: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc27a9c: 4b ff 4d a1 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc27aa0: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc27aa4: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc27aa8: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc27aac: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc27ab0: 48 00 32 95 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc27ab4: 4b ff ff ac b ffc27a60 <rtems_rfs_rtems_dir_open+0xb4><== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc27ab8: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc27abc: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc27ac0: 4b fe fe a9 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc27ac4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc27ac8: 41 9e ff 2c beq+ cr7,ffc279f4 <rtems_rfs_rtems_dir_open+0x48><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
ffc27acc: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc27ad0: 4b ff 4d 6d bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc27ad4: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc27ad8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc27adc: 38 63 bb 30 addi r3,r3,-17616 <== NOT EXECUTED
ffc27ae0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc27ae4: 48 00 32 61 bl ffc2ad44 <printf> <== NOT EXECUTED
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc27ae8: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc27aec: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc27af0: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
ffc27af4: 38 c0 00 01 li r6,1 <== NOT EXECUTED
ffc27af8: 4b fe c4 e1 bl ffc13fd8 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
ffc27afc: 7c 7d 1b 79 mr. r29,r3 <== NOT EXECUTED
ffc27b00: 41 82 ff 10 beq+ ffc27a10 <rtems_rfs_rtems_dir_open+0x64><== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc27b04: 83 df 00 7c lwz r30,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc27b08: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc27b0c: 4b ff b2 d9 bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc27b10: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc27b14: 4b fe 5e 05 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc27b18: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc27b1c: 40 82 00 34 bne- ffc27b50 <rtems_rfs_rtems_dir_open+0x1a4><== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_open: opening inode", rc);
ffc27b20: 48 00 21 41 bl ffc29c60 <__errno> <== NOT EXECUTED
iop->offset = 0;
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
return 0;
}
ffc27b24: 80 01 00 4c lwz r0,76(r1) <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
if (rc)
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_open: opening inode", rc);
ffc27b28: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc27b2c: 93 a3 00 00 stw r29,0(r3) <== NOT EXECUTED
iop->offset = 0;
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
return 0;
}
ffc27b30: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc27b34: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc27b38: 83 81 00 38 lwz r28,56(r1) <== NOT EXECUTED
ffc27b3c: 83 a1 00 3c lwz r29,60(r1) <== NOT EXECUTED
ffc27b40: 83 c1 00 40 lwz r30,64(r1) <== NOT EXECUTED
ffc27b44: 83 e1 00 44 lwz r31,68(r1) <== NOT EXECUTED
ffc27b48: 38 21 00 48 addi r1,r1,72 <== NOT EXECUTED
ffc27b4c: 4e 80 00 20 blr <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc27b50: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc27b54: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc27b58: 4b fe fe 11 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc27b5c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc27b60: 41 9e ff c0 beq+ cr7,ffc27b20 <rtems_rfs_rtems_dir_open+0x174><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc27b64: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc27b68: 4b ff 4c d5 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc27b6c: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc27b70: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc27b74: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc27b78: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc27b7c: 48 00 31 c9 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc27b80: 4b ff ff a0 b ffc27b20 <rtems_rfs_rtems_dir_open+0x174><== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_open: opening inode", rc);
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
{
rtems_rfs_inode_close (fs, &inode);
ffc27b84: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc27b88: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc27b8c: 4b fe c6 ad bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc27b90: 83 df 00 7c lwz r30,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc27b94: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc27b98: 4b ff b2 4d bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc27b9c: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc27ba0: 4b fe 5d 79 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc27ba4: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc27ba8: 40 82 00 18 bne- ffc27bc0 <rtems_rfs_rtems_dir_open+0x214><== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);
ffc27bac: 48 00 20 b5 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc27bb0: 38 00 00 14 li r0,20 <== NOT EXECUTED
ffc27bb4: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc27bb8: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc27bbc: 4b ff fe a4 b ffc27a60 <rtems_rfs_rtems_dir_open+0xb4><== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc27bc0: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc27bc4: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc27bc8: 4b fe fd a1 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc27bcc: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc27bd0: 41 9e ff dc beq+ cr7,ffc27bac <rtems_rfs_rtems_dir_open+0x200><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc27bd4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc27bd8: 4b ff 4c 65 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc27bdc: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc27be0: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc27be4: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc27be8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc27bec: 48 00 31 59 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc27bf0: 4b ff ff bc b ffc27bac <rtems_rfs_rtems_dir_open+0x200><== NOT EXECUTED
ffc276c0 <rtems_rfs_rtems_dir_read>:
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
ffc276c0: 94 21 ff a0 stwu r1,-96(r1) <== NOT EXECUTED
ffc276c4: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc276c8: 90 01 00 64 stw r0,100(r1) <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
ffc276cc: 81 23 00 2c lwz r9,44(r3) <== NOT EXECUTED
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
ffc276d0: 93 41 00 48 stw r26,72(r1) <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
ffc276d4: 83 49 00 34 lwz r26,52(r9) <== NOT EXECUTED
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
ffc276d8: 93 61 00 4c stw r27,76(r1) <== NOT EXECUTED
ffc276dc: 7c 7b 1b 78 mr r27,r3 <== NOT EXECUTED
.fpathconf_h = rtems_filesystem_default_fpathconf,
.fsync_h = rtems_filesystem_default_fsync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl,
.rmnod_h = rtems_rfs_rtems_dir_rmnod
};
ffc276e0: 81 3a 00 7c lwz r9,124(r26) <== NOT EXECUTED
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
ffc276e4: 93 01 00 40 stw r24,64(r1) <== NOT EXECUTED
ffc276e8: 7c b8 2b 78 mr r24,r5 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
ffc276ec: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc276f0: 80 69 00 00 lwz r3,0(r9) <== NOT EXECUTED
ffc276f4: 93 21 00 44 stw r25,68(r1) <== NOT EXECUTED
ffc276f8: 7c 99 23 78 mr r25,r4 <== NOT EXECUTED
ffc276fc: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc27700: 93 81 00 50 stw r28,80(r1) <== NOT EXECUTED
ffc27704: 93 a1 00 54 stw r29,84(r1) <== NOT EXECUTED
ffc27708: 92 e1 00 3c stw r23,60(r1) <== NOT EXECUTED
ffc2770c: 93 c1 00 58 stw r30,88(r1) <== NOT EXECUTED
ffc27710: 93 e1 00 5c stw r31,92(r1) <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
ffc27714: 83 bb 00 1c lwz r29,28(r27) <== NOT EXECUTED
ffc27718: 4b fe 60 75 bl ffc0d78c <rtems_semaphore_obtain> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc2771c: 7c 7c 1b 79 mr. r28,r3 <== NOT EXECUTED
ffc27720: 40 82 01 6c bne- ffc2788c <rtems_rfs_rtems_dir_read+0x1cc><== NOT EXECUTED
count = count / sizeof (struct dirent);
dirent = buffer;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc27724: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc27728: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc2772c: 38 a1 00 0c addi r5,r1,12 <== NOT EXECUTED
ffc27730: 38 c0 00 01 li r6,1 <== NOT EXECUTED
ffc27734: 4b fe c8 a5 bl ffc13fd8 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
ffc27738: 7c 7d 1b 79 mr. r29,r3 <== NOT EXECUTED
ffc2773c: 40 82 01 9c bne- ffc278d8 <rtems_rfs_rtems_dir_read+0x218><== NOT EXECUTED
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
ffc27740: 3c 00 0e a0 lis r0,3744 <== NOT EXECUTED
ffc27744: 57 18 e8 fe rlwinm r24,r24,29,3,31 <== NOT EXECUTED
ffc27748: 60 00 ea 0f ori r0,r0,59919 <== NOT EXECUTED
ffc2774c: 7f 18 00 16 mulhwu r24,r24,r0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
ffc27750: 57 18 f8 7f rlwinm. r24,r24,31,1,31 <== NOT EXECUTED
ffc27754: 41 82 02 50 beq- ffc279a4 <rtems_rfs_rtems_dir_read+0x2e4><== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
if (rc)
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
ffc27758: 80 bb 00 10 lwz r5,16(r27) <== NOT EXECUTED
* exisiting file, the remaining entries will be placed in the buffer and the
* returned value will be equal to -m actual- times the size of a directory
* entry.
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
ffc2775c: 3b 80 00 00 li r28,0 <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
if (rc)
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
ffc27760: 80 db 00 14 lwz r6,20(r27) <== NOT EXECUTED
* exisiting file, the remaining entries will be placed in the buffer and the
* returned value will be equal to -m actual- times the size of a directory
* entry.
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
ffc27764: 3b a0 00 00 li r29,0 <== NOT EXECUTED
ffc27768: 48 00 00 30 b ffc27798 <rtems_rfs_rtems_dir_read+0xd8><== NOT EXECUTED
if (rc == ENOENT)
{
rc = 0;
break;
}
if (rc > 0)
ffc2776c: 41 99 01 cc bgt- cr6,ffc27938 <rtems_rfs_rtems_dir_read+0x278><== NOT EXECUTED
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
break;
}
iop->offset += size;
ffc27770: 81 5b 00 10 lwz r10,16(r27) <== NOT EXECUTED
ffc27774: 3b c0 00 00 li r30,0 <== NOT EXECUTED
ffc27778: 81 7b 00 14 lwz r11,20(r27) <== NOT EXECUTED
* exisiting file, the remaining entries will be placed in the buffer and the
* returned value will be equal to -m actual- times the size of a directory
* entry.
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
ffc2777c: 3b bd 01 18 addi r29,r29,280 <== NOT EXECUTED
if (rc > 0)
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
break;
}
iop->offset += size;
ffc27780: 83 e1 00 08 lwz r31,8(r1) <== NOT EXECUTED
ffc27784: 7c df 58 14 addc r6,r31,r11 <== NOT EXECUTED
ffc27788: 7c be 51 14 adde r5,r30,r10 <== NOT EXECUTED
ffc2778c: 90 bb 00 10 stw r5,16(r27) <== NOT EXECUTED
ffc27790: 90 db 00 14 stw r6,20(r27) <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
ffc27794: 41 86 00 30 beq- cr1,ffc277c4 <rtems_rfs_rtems_dir_read+0x104><== NOT EXECUTED
{
size_t size;
rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size);
ffc27798: 7c f9 ea 14 add r7,r25,r29 <== NOT EXECUTED
ffc2779c: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc277a0: 38 81 00 0c addi r4,r1,12 <== NOT EXECUTED
ffc277a4: 39 01 00 08 addi r8,r1,8 <== NOT EXECUTED
ffc277a8: 4b ff c8 99 bl ffc24040 <rtems_rfs_dir_read> <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
ffc277ac: 3b 9c 00 01 addi r28,r28,1 <== NOT EXECUTED
{
size_t size;
rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size);
if (rc == ENOENT)
ffc277b0: 2f 83 00 02 cmpwi cr7,r3,2 <== NOT EXECUTED
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
{
size_t size;
rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size);
ffc277b4: 7c 77 1b 78 mr r23,r3 <== NOT EXECUTED
if (rc == ENOENT)
{
rc = 0;
break;
}
if (rc > 0)
ffc277b8: 2f 03 00 00 cmpwi cr6,r3,0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
ffc277bc: 7c 9c c0 00 cmpw cr1,r28,r24 <== NOT EXECUTED
{
size_t size;
rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size);
if (rc == ENOENT)
ffc277c0: 40 9e ff ac bne+ cr7,ffc2776c <rtems_rfs_rtems_dir_read+0xac><== NOT EXECUTED
}
iop->offset += size;
bytes_transferred += sizeof (struct dirent);
}
rtems_rfs_inode_close (fs, &inode);
ffc277c4: 38 81 00 0c addi r4,r1,12 <== NOT EXECUTED
ffc277c8: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc277cc: 4b fe ca 6d bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc277d0: 83 da 00 7c lwz r30,124(r26) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc277d4: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc277d8: 4b ff b6 0d bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc277dc: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc277e0: 4b fe 61 39 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc277e4: 7c 7e 1b 79 mr. r30,r3 <== NOT EXECUTED
ffc277e8: 40 82 00 3c bne- ffc27824 <rtems_rfs_rtems_dir_read+0x164><== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return bytes_transferred;
}
ffc277ec: 80 01 00 64 lwz r0,100(r1) <== NOT EXECUTED
ffc277f0: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc277f4: 82 e1 00 3c lwz r23,60(r1) <== NOT EXECUTED
ffc277f8: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc277fc: 83 01 00 40 lwz r24,64(r1) <== NOT EXECUTED
ffc27800: 83 21 00 44 lwz r25,68(r1) <== NOT EXECUTED
ffc27804: 83 41 00 48 lwz r26,72(r1) <== NOT EXECUTED
ffc27808: 83 61 00 4c lwz r27,76(r1) <== NOT EXECUTED
ffc2780c: 83 81 00 50 lwz r28,80(r1) <== NOT EXECUTED
ffc27810: 83 a1 00 54 lwz r29,84(r1) <== NOT EXECUTED
ffc27814: 83 c1 00 58 lwz r30,88(r1) <== NOT EXECUTED
ffc27818: 83 e1 00 5c lwz r31,92(r1) <== NOT EXECUTED
ffc2781c: 38 21 00 60 addi r1,r1,96 <== NOT EXECUTED
ffc27820: 4e 80 00 20 blr <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc27824: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc27828: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc2782c: 4b ff 01 3d bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc27830: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc27834: 41 9e ff b8 beq+ cr7,ffc277ec <rtems_rfs_rtems_dir_read+0x12c><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc27838: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc2783c: 4b ff 50 01 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc27840: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc27844: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc27848: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc2784c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc27850: 48 00 34 f5 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc27854: 80 01 00 64 lwz r0,100(r1) <== NOT EXECUTED
ffc27858: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc2785c: 82 e1 00 3c lwz r23,60(r1) <== NOT EXECUTED
ffc27860: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc27864: 83 01 00 40 lwz r24,64(r1) <== NOT EXECUTED
ffc27868: 83 21 00 44 lwz r25,68(r1) <== NOT EXECUTED
ffc2786c: 83 41 00 48 lwz r26,72(r1) <== NOT EXECUTED
ffc27870: 83 61 00 4c lwz r27,76(r1) <== NOT EXECUTED
ffc27874: 83 81 00 50 lwz r28,80(r1) <== NOT EXECUTED
ffc27878: 83 a1 00 54 lwz r29,84(r1) <== NOT EXECUTED
ffc2787c: 83 c1 00 58 lwz r30,88(r1) <== NOT EXECUTED
ffc27880: 83 e1 00 5c lwz r31,92(r1) <== NOT EXECUTED
ffc27884: 38 21 00 60 addi r1,r1,96 <== NOT EXECUTED
ffc27888: 4e 80 00 20 blr <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc2788c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc27890: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc27894: 4b ff 00 d5 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc27898: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc2789c: 41 9e fe 88 beq+ cr7,ffc27724 <rtems_rfs_rtems_dir_read+0x64><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
ffc278a0: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc278a4: 4b ff 4f 99 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc278a8: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc278ac: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc278b0: 38 63 bb 30 addi r3,r3,-17616 <== NOT EXECUTED
ffc278b4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc278b8: 48 00 34 8d bl ffc2ad44 <printf> <== NOT EXECUTED
count = count / sizeof (struct dirent);
dirent = buffer;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc278bc: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc278c0: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc278c4: 38 a1 00 0c addi r5,r1,12 <== NOT EXECUTED
ffc278c8: 38 c0 00 01 li r6,1 <== NOT EXECUTED
ffc278cc: 4b fe c7 0d bl ffc13fd8 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
ffc278d0: 7c 7d 1b 79 mr. r29,r3 <== NOT EXECUTED
ffc278d4: 41 82 fe 6c beq+ ffc27740 <rtems_rfs_rtems_dir_read+0x80><== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc278d8: 83 da 00 7c lwz r30,124(r26) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc278dc: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc278e0: 4b ff b5 05 bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc278e4: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc278e8: 4b fe 60 31 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc278ec: 7c 7e 1b 79 mr. r30,r3 <== NOT EXECUTED
ffc278f0: 40 82 00 80 bne- ffc27970 <rtems_rfs_rtems_dir_read+0x2b0><== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
ffc278f4: 48 00 23 6d bl ffc29c60 <__errno> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
return bytes_transferred;
}
ffc278f8: 80 01 00 64 lwz r0,100(r1) <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
if (rc)
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
ffc278fc: 93 a3 00 00 stw r29,0(r3) <== NOT EXECUTED
ffc27900: 3b a0 ff ff li r29,-1 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
return bytes_transferred;
}
ffc27904: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc27908: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc2790c: 82 e1 00 3c lwz r23,60(r1) <== NOT EXECUTED
ffc27910: 83 01 00 40 lwz r24,64(r1) <== NOT EXECUTED
ffc27914: 83 21 00 44 lwz r25,68(r1) <== NOT EXECUTED
ffc27918: 83 41 00 48 lwz r26,72(r1) <== NOT EXECUTED
ffc2791c: 83 61 00 4c lwz r27,76(r1) <== NOT EXECUTED
ffc27920: 83 81 00 50 lwz r28,80(r1) <== NOT EXECUTED
ffc27924: 83 a1 00 54 lwz r29,84(r1) <== NOT EXECUTED
ffc27928: 83 c1 00 58 lwz r30,88(r1) <== NOT EXECUTED
ffc2792c: 83 e1 00 5c lwz r31,92(r1) <== NOT EXECUTED
ffc27930: 38 21 00 60 addi r1,r1,96 <== NOT EXECUTED
ffc27934: 4e 80 00 20 blr <== NOT EXECUTED
rc = 0;
break;
}
if (rc > 0)
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
ffc27938: 48 00 23 29 bl ffc29c60 <__errno> <== NOT EXECUTED
}
iop->offset += size;
bytes_transferred += sizeof (struct dirent);
}
rtems_rfs_inode_close (fs, &inode);
ffc2793c: 38 81 00 0c addi r4,r1,12 <== NOT EXECUTED
rc = 0;
break;
}
if (rc > 0)
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
ffc27940: 92 e3 00 00 stw r23,0(r3) <== NOT EXECUTED
}
iop->offset += size;
bytes_transferred += sizeof (struct dirent);
}
rtems_rfs_inode_close (fs, &inode);
ffc27944: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
rc = 0;
break;
}
if (rc > 0)
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
ffc27948: 3b a0 ff ff li r29,-1 <== NOT EXECUTED
}
iop->offset += size;
bytes_transferred += sizeof (struct dirent);
}
rtems_rfs_inode_close (fs, &inode);
ffc2794c: 4b fe c8 ed bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc27950: 83 da 00 7c lwz r30,124(r26) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc27954: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc27958: 4b ff b4 8d bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc2795c: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc27960: 4b fe 5f b9 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc27964: 7c 7e 1b 79 mr. r30,r3 <== NOT EXECUTED
ffc27968: 41 82 fe 84 beq+ ffc277ec <rtems_rfs_rtems_dir_read+0x12c><== NOT EXECUTED
ffc2796c: 4b ff fe b8 b ffc27824 <rtems_rfs_rtems_dir_read+0x164><== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc27970: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc27974: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc27978: 4b fe ff f1 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc2797c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc27980: 41 9e ff 74 beq+ cr7,ffc278f4 <rtems_rfs_rtems_dir_read+0x234><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc27984: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc27988: 4b ff 4e b5 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc2798c: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc27990: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc27994: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc27998: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc2799c: 48 00 33 a9 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc279a0: 4b ff ff 54 b ffc278f4 <rtems_rfs_rtems_dir_read+0x234><== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
ffc279a4: 3b a0 00 00 li r29,0 <== NOT EXECUTED
ffc279a8: 4b ff fe 1c b ffc277c4 <rtems_rfs_rtems_dir_read+0x104><== NOT EXECUTED
ffc27500 <rtems_rfs_rtems_dir_rmnod>:
static int
rtems_rfs_rtems_dir_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
ffc27500: 94 21 ff e0 stwu r1,-32(r1) <== NOT EXECUTED
ffc27504: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc27508: 90 01 00 24 stw r0,36(r1) <== NOT EXECUTED
ffc2750c: 93 c1 00 18 stw r30,24(r1) <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_pathloc);
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
ffc27510: 83 c4 00 00 lwz r30,0(r4) <== NOT EXECUTED
static int
rtems_rfs_rtems_dir_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc27514: 81 24 00 10 lwz r9,16(r4) <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_DIR_RMNOD))
printf ("rtems-rfs: dir-rmnod: parent:%" PRId32 " doff:%" PRIu32 ", ino:%" PRId32 "\n",
parent, doff, ino);
if (ino == RTEMS_RFS_ROOT_INO)
ffc27518: 2f 9e 00 01 cmpwi cr7,r30,1 <== NOT EXECUTED
}
static int
rtems_rfs_rtems_dir_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
ffc2751c: 93 81 00 10 stw r28,16(r1) <== NOT EXECUTED
ffc27520: 93 a1 00 14 stw r29,20(r1) <== NOT EXECUTED
ffc27524: 93 e1 00 1c stw r31,28(r1) <== NOT EXECUTED
ffc27528: 93 61 00 0c stw r27,12(r1) <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc2752c: 83 e9 00 34 lwz r31,52(r9) <== NOT EXECUTED
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_pathloc);
ffc27530: 83 83 00 00 lwz r28,0(r3) <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
uint32_t doff = rtems_rfs_rtems_get_pathloc_doff (pathloc);
ffc27534: 83 a4 00 04 lwz r29,4(r4) <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_DIR_RMNOD))
printf ("rtems-rfs: dir-rmnod: parent:%" PRId32 " doff:%" PRIu32 ", ino:%" PRId32 "\n",
parent, doff, ino);
if (ino == RTEMS_RFS_ROOT_INO)
ffc27538: 41 9e 01 74 beq- cr7,ffc276ac <rtems_rfs_rtems_dir_rmnod+0x1ac><== NOT EXECUTED
.fpathconf_h = rtems_filesystem_default_fpathconf,
.fsync_h = rtems_filesystem_default_fsync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl,
.rmnod_h = rtems_rfs_rtems_dir_rmnod
};
ffc2753c: 81 3f 00 7c lwz r9,124(r31) <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
ffc27540: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc27544: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc27548: 80 69 00 00 lwz r3,0(r9) <== NOT EXECUTED
ffc2754c: 4b fe 62 41 bl ffc0d78c <rtems_semaphore_obtain> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc27550: 7c 7b 1b 79 mr. r27,r3 <== NOT EXECUTED
ffc27554: 40 82 00 bc bne- ffc27610 <rtems_rfs_rtems_dir_rmnod+0x110><== NOT EXECUTED
if (ino == RTEMS_RFS_ROOT_INO)
return rtems_rfs_rtems_error ("dir_rmnod: root inode", EBUSY);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_if_empty);
ffc27558: 7f c5 f3 78 mr r5,r30 <== NOT EXECUTED
ffc2755c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc27560: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc27564: 7f a6 eb 78 mr r6,r29 <== NOT EXECUTED
ffc27568: 38 e0 00 01 li r7,1 <== NOT EXECUTED
ffc2756c: 4b ff f0 05 bl ffc26570 <rtems_rfs_unlink> <== NOT EXECUTED
if (rc)
ffc27570: 7c 7e 1b 79 mr. r30,r3 <== NOT EXECUTED
ffc27574: 41 82 00 54 beq- ffc275c8 <rtems_rfs_rtems_dir_rmnod+0xc8><== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc27578: 83 bf 00 7c lwz r29,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc2757c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc27580: 4b ff b8 65 bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc27584: 80 7d 00 00 lwz r3,0(r29) <== NOT EXECUTED
ffc27588: 4b fe 63 91 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc2758c: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc27590: 40 82 00 b4 bne- ffc27644 <rtems_rfs_rtems_dir_rmnod+0x144><== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_rmnod: unlinking", rc);
ffc27594: 48 00 26 cd bl ffc29c60 <__errno> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
ffc27598: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_if_empty);
if (rc)
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_rmnod: unlinking", rc);
ffc2759c: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc275a0: 93 c3 00 00 stw r30,0(r3) <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
ffc275a4: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc275a8: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc275ac: 83 61 00 0c lwz r27,12(r1) <== NOT EXECUTED
ffc275b0: 83 81 00 10 lwz r28,16(r1) <== NOT EXECUTED
ffc275b4: 83 a1 00 14 lwz r29,20(r1) <== NOT EXECUTED
ffc275b8: 83 c1 00 18 lwz r30,24(r1) <== NOT EXECUTED
ffc275bc: 83 e1 00 1c lwz r31,28(r1) <== NOT EXECUTED
ffc275c0: 38 21 00 20 addi r1,r1,32 <== NOT EXECUTED
ffc275c4: 4e 80 00 20 blr <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc275c8: 83 df 00 7c lwz r30,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc275cc: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc275d0: 4b ff b8 15 bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_rmnod: unlinking", rc);
}
rtems_rfs_rtems_unlock (fs);
return 0;
ffc275d4: 3b e0 00 00 li r31,0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc275d8: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc275dc: 4b fe 63 3d bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc275e0: 7c 7e 1b 79 mr. r30,r3 <== NOT EXECUTED
ffc275e4: 40 82 00 94 bne- ffc27678 <rtems_rfs_rtems_dir_rmnod+0x178><== NOT EXECUTED
}
ffc275e8: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
ffc275ec: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc275f0: 83 61 00 0c lwz r27,12(r1) <== NOT EXECUTED
ffc275f4: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc275f8: 83 81 00 10 lwz r28,16(r1) <== NOT EXECUTED
ffc275fc: 83 a1 00 14 lwz r29,20(r1) <== NOT EXECUTED
ffc27600: 83 c1 00 18 lwz r30,24(r1) <== NOT EXECUTED
ffc27604: 83 e1 00 1c lwz r31,28(r1) <== NOT EXECUTED
ffc27608: 38 21 00 20 addi r1,r1,32 <== NOT EXECUTED
ffc2760c: 4e 80 00 20 blr <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc27610: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc27614: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc27618: 4b ff 03 51 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc2761c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc27620: 41 9e ff 38 beq+ cr7,ffc27558 <rtems_rfs_rtems_dir_rmnod+0x58><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
ffc27624: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc27628: 4b ff 52 15 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc2762c: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc27630: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc27634: 38 63 bb 30 addi r3,r3,-17616 <== NOT EXECUTED
ffc27638: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc2763c: 48 00 37 09 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc27640: 4b ff ff 18 b ffc27558 <rtems_rfs_rtems_dir_rmnod+0x58><== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc27644: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc27648: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc2764c: 4b ff 03 1d bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc27650: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc27654: 41 9e ff 40 beq+ cr7,ffc27594 <rtems_rfs_rtems_dir_rmnod+0x94><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc27658: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc2765c: 4b ff 51 e1 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc27660: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc27664: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc27668: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc2766c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc27670: 48 00 36 d5 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc27674: 4b ff ff 20 b ffc27594 <rtems_rfs_rtems_dir_rmnod+0x94><== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc27678: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc2767c: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc27680: 4b ff 02 e9 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc27684: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc27688: 41 9e ff 60 beq+ cr7,ffc275e8 <rtems_rfs_rtems_dir_rmnod+0xe8><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc2768c: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc27690: 4b ff 51 ad bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc27694: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc27698: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc2769c: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc276a0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc276a4: 48 00 36 a1 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc276a8: 4b ff ff 40 b ffc275e8 <rtems_rfs_rtems_dir_rmnod+0xe8><== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_DIR_RMNOD))
printf ("rtems-rfs: dir-rmnod: parent:%" PRId32 " doff:%" PRIu32 ", ino:%" PRId32 "\n",
parent, doff, ino);
if (ino == RTEMS_RFS_ROOT_INO)
return rtems_rfs_rtems_error ("dir_rmnod: root inode", EBUSY);
ffc276ac: 48 00 25 b5 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc276b0: 38 00 00 10 li r0,16 <== NOT EXECUTED
ffc276b4: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc276b8: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc276bc: 4b ff ff 2c b ffc275e8 <rtems_rfs_rtems_dir_rmnod+0xe8><== NOT EXECUTED
ffc16724 <rtems_rfs_rtems_eval_for_make>:
*/
static int
rtems_rfs_rtems_eval_for_make (const char* path,
rtems_filesystem_location_info_t* pathloc,
const char** name)
{
ffc16724: 94 21 ff 98 stwu r1,-104(r1)
ffc16728: 7c 08 02 a6 mflr r0
ffc1672c: 90 01 00 6c stw r0,108(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
ffc16730: 80 04 00 00 lwz r0,0(r4)
static int
rtems_rfs_rtems_eval_for_make (const char* path,
rtems_filesystem_location_info_t* pathloc,
const char** name)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc16734: 81 24 00 10 lwz r9,16(r4)
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
ffc16738: 90 01 00 10 stw r0,16(r1)
rtems_rfs_ino node_ino;
uint32_t doff = 0;
ffc1673c: 38 00 00 00 li r0,0
*/
static int
rtems_rfs_rtems_eval_for_make (const char* path,
rtems_filesystem_location_info_t* pathloc,
const char** name)
{
ffc16740: 93 41 00 50 stw r26,80(r1)
ffc16744: 7c 7a 1b 78 mr r26,r3
ffc16748: 93 81 00 58 stw r28,88(r1)
ffc1674c: 7c 9c 23 78 mr r28,r4
ffc16750: 93 c1 00 60 stw r30,96(r1)
ffc16754: 7c be 2b 78 mr r30,r5
ffc16758: 93 e1 00 64 stw r31,100(r1)
ffc1675c: 93 21 00 4c stw r25,76(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc16760: 83 e9 00 34 lwz r31,52(r9)
*/
static int
rtems_rfs_rtems_eval_for_make (const char* path,
rtems_filesystem_location_info_t* pathloc,
const char** name)
{
ffc16764: 93 61 00 54 stw r27,84(r1)
ffc16768: 93 a1 00 5c stw r29,92(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
rtems_rfs_ino node_ino;
uint32_t doff = 0;
ffc1676c: 90 01 00 08 stw r0,8(r1)
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
printf ("rtems-rfs-rtems: eval-for-make: path:%s ino:%" PRId32 "\n", path, ino);
*name = path + strlen (path);
ffc16770: 48 01 53 59 bl ffc2bac8 <strlen>
ffc16774: 7c 7a 1a 14 add r3,r26,r3
ffc16778: 90 7e 00 00 stw r3,0(r30)
while (*name != path)
ffc1677c: 48 00 00 08 b ffc16784 <rtems_rfs_rtems_eval_for_make+0x60>
{
(*name)--;
if (rtems_filesystem_is_separator (**name))
{
(*name)++;
break;
ffc16780: 80 7e 00 00 lwz r3,0(r30)
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
printf ("rtems-rfs-rtems: eval-for-make: path:%s ino:%" PRId32 "\n", path, ino);
*name = path + strlen (path);
while (*name != path)
ffc16784: 7f 9a 18 00 cmpw cr7,r26,r3
{
(*name)--;
ffc16788: 38 03 ff ff addi r0,r3,-1
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
printf ("rtems-rfs-rtems: eval-for-make: path:%s ino:%" PRId32 "\n", path, ino);
*name = path + strlen (path);
while (*name != path)
ffc1678c: 41 9e 00 24 beq- cr7,ffc167b0 <rtems_rfs_rtems_eval_for_make+0x8c>
{
(*name)--;
ffc16790: 90 1e 00 00 stw r0,0(r30)
if (rtems_filesystem_is_separator (**name))
ffc16794: 88 63 ff ff lbz r3,-1(r3)
ffc16798: 4b ff 3c 4d bl ffc0a3e4 <rtems_filesystem_is_separator>
ffc1679c: 2f 83 00 00 cmpwi cr7,r3,0
ffc167a0: 41 9e ff e0 beq+ cr7,ffc16780 <rtems_rfs_rtems_eval_for_make+0x5c>
{
(*name)++;
ffc167a4: 81 3e 00 00 lwz r9,0(r30)
ffc167a8: 38 09 00 01 addi r0,r9,1
ffc167ac: 90 1e 00 00 stw r0,0(r30)
}
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen(path));
ffc167b0: 7f 43 d3 78 mr r3,r26
ffc167b4: 48 01 53 15 bl ffc2bac8 <strlen>
ffc167b8: 7c 64 1b 78 mr r4,r3
ffc167bc: 7f 43 d3 78 mr r3,r26
ffc167c0: 4b ff 1a f1 bl ffc082b0 <rtems_filesystem_prefix_separators>
rtems_rfs_mutex_destroy (&rtems->access);
free (rtems);
return rtems_rfs_rtems_error ("shutdown: close", rc);
}
ffc167c4: 81 3f 00 7c lwz r9,124(r31)
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen(path));
path += stripped;
ffc167c8: 7f 5a 1a 14 add r26,r26,r3
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
ffc167cc: 80 69 00 00 lwz r3,0(r9)
ffc167d0: 38 80 00 00 li r4,0
ffc167d4: 38 a0 00 00 li r5,0
ffc167d8: 4b ff 6f b5 bl ffc0d78c <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
ffc167dc: 7c 7d 1b 79 mr. r29,r3
ffc167e0: 40 82 02 70 bne- ffc16a50 <rtems_rfs_rtems_eval_for_make+0x32c><== NEVER TAKEN
}
/*
* We need to find the parent of this node.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, "..", 2, &ino, &doff);
ffc167e4: 3f 60 ff c4 lis r27,-60
ffc167e8: 3b 7b 9c b4 addi r27,r27,-25420
while (true)
{
/*
* Open and load the inode.
*/
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc167ec: 80 81 00 10 lwz r4,16(r1)
ffc167f0: 7f e3 fb 78 mr r3,r31
ffc167f4: 38 a1 00 14 addi r5,r1,20
ffc167f8: 38 c0 00 01 li r6,1
ffc167fc: 4b ff d7 dd bl ffc13fd8 <rtems_rfs_inode_open>
if (rc > 0)
ffc16800: 7c 7d 1b 79 mr. r29,r3
ffc16804: 41 81 03 d8 bgt- ffc16bdc <rtems_rfs_rtems_eval_for_make+0x4b8><== NEVER TAKEN
}
/*
* If a directory the execute bit must be set for us to enter.
*/
if (RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)) &&
ffc16808: 81 21 00 20 lwz r9,32(r1)
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
ffc1680c: 88 09 00 02 lbz r0,2(r9)
ffc16810: 54 00 44 26 rlwinm r0,r0,8,16,19
ffc16814: 2f 80 40 00 cmpwi cr7,r0,16384
ffc16818: 41 9e 01 a8 beq- cr7,ffc169c0 <rtems_rfs_rtems_eval_for_make+0x29c>
}
/*
* Is this the end of the pathname we where given ?
*/
if (path == *name)
ffc1681c: 80 1e 00 00 lwz r0,0(r30)
ffc16820: 7f 80 d0 00 cmpw cr7,r0,r26
ffc16824: 41 9e 00 d8 beq- cr7,ffc168fc <rtems_rfs_rtems_eval_for_make+0x1d8>
ffc16828: 7f 5d d3 78 mr r29,r26
ffc1682c: 3b 20 00 00 li r25,0
ffc16830: 48 00 00 28 b ffc16858 <rtems_rfs_rtems_eval_for_make+0x134>
/*
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator(*path) &&
ffc16834: 88 1d 00 00 lbz r0,0(r29)
ffc16838: 2f 80 00 00 cmpwi cr7,r0,0
ffc1683c: 41 9e 00 2c beq- cr7,ffc16868 <rtems_rfs_rtems_eval_for_make+0x144><== NEVER TAKEN
(*path != '\0') &&
(node_len < (rtems_rfs_fs_max_name (fs) - 1)))
ffc16840: 81 3f 00 18 lwz r9,24(r31)
ffc16844: 38 09 ff ff addi r0,r9,-1
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator(*path) &&
(*path != '\0') &&
ffc16848: 7f 99 00 40 cmplw cr7,r25,r0
ffc1684c: 40 9c 00 1c bge- cr7,ffc16868 <rtems_rfs_rtems_eval_for_make+0x144><== NEVER TAKEN
(node_len < (rtems_rfs_fs_max_name (fs) - 1)))
{
node_len++;
ffc16850: 3b 39 00 01 addi r25,r25,1
path++;
ffc16854: 3b bd 00 01 addi r29,r29,1
/*
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator(*path) &&
ffc16858: 88 7d 00 00 lbz r3,0(r29)
ffc1685c: 4b ff 3b 89 bl ffc0a3e4 <rtems_filesystem_is_separator>
ffc16860: 2f 83 00 00 cmpwi cr7,r3,0
ffc16864: 41 9e ff d0 beq+ cr7,ffc16834 <rtems_rfs_rtems_eval_for_make+0x110>
}
/*
* Eat any separators at start of the new path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen (path));
ffc16868: 7f a3 eb 78 mr r3,r29
ffc1686c: 48 01 52 5d bl ffc2bac8 <strlen>
ffc16870: 7c 64 1b 78 mr r4,r3
ffc16874: 7f a3 eb 78 mr r3,r29
ffc16878: 4b ff 1a 39 bl ffc082b0 <rtems_filesystem_prefix_separators>
/*
* If the node is the current directory and there is more path to come move
* on it else we are at the inode we want.
*/
if (rtems_rfs_current_dir (node))
ffc1687c: 88 1a 00 00 lbz r0,0(r26)
/*
* Eat any separators at start of the new path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen (path));
path += stripped;
ffc16880: 7f bd 1a 14 add r29,r29,r3
/*
* If the node is the current directory and there is more path to come move
* on it else we are at the inode we want.
*/
if (rtems_rfs_current_dir (node))
ffc16884: 2f 80 00 2e cmpwi cr7,r0,46
ffc16888: 41 9e 00 5c beq- cr7,ffc168e4 <rtems_rfs_rtems_eval_for_make+0x1c0><== NEVER TAKEN
/*
* If the node is a parent we must move up one directory. If the location
* is on another file system we have a crossmount so we call that file
* system to handle the remainder of the path.
*/
if (rtems_rfs_parent_dir (path))
ffc1688c: 88 1d 00 00 lbz r0,0(r29)
ffc16890: 2f 80 00 2e cmpwi cr7,r0,46
ffc16894: 40 9e 00 10 bne- cr7,ffc168a4 <rtems_rfs_rtems_eval_for_make+0x180><== ALWAYS TAKEN
ffc16898: 88 1d 00 01 lbz r0,1(r29) <== NOT EXECUTED
ffc1689c: 2f 80 00 2e cmpwi cr7,r0,46 <== NOT EXECUTED
ffc168a0: 41 9e 01 70 beq- cr7,ffc16a10 <rtems_rfs_rtems_eval_for_make+0x2ec><== NOT EXECUTED
else
{
/*
* Read the inode so we know it exists and what type it is.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode,
ffc168a4: 7f e3 fb 78 mr r3,r31
ffc168a8: 38 81 00 14 addi r4,r1,20
ffc168ac: 7f 45 d3 78 mr r5,r26
ffc168b0: 7f 26 cb 78 mr r6,r25
ffc168b4: 38 e1 00 10 addi r7,r1,16
ffc168b8: 39 01 00 08 addi r8,r1,8
ffc168bc: 48 00 c7 f9 bl ffc230b4 <rtems_rfs_dir_lookup_ino>
node, node_len - stripped, &ino, &doff);
if (rc > 0)
ffc168c0: 7c 7a 1b 79 mr. r26,r3
ffc168c4: 41 81 02 70 bgt- ffc16b34 <rtems_rfs_rtems_eval_for_make+0x410>
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
printf("rtems-rfs-rtems: eval-for-make: down: path:%s ino:%" PRId32 "\n",
node, ino);
}
rc = rtems_rfs_inode_close (fs, &inode);
ffc168c8: 7f e3 fb 78 mr r3,r31
ffc168cc: 38 81 00 14 addi r4,r1,20
ffc168d0: 4b ff d9 69 bl ffc14238 <rtems_rfs_inode_close>
if (rc > 0)
ffc168d4: 7c 7a 1b 79 mr. r26,r3
ffc168d8: 41 81 02 68 bgt- ffc16b40 <rtems_rfs_rtems_eval_for_make+0x41c><== NEVER TAKEN
/*
* Eat any separators at start of the new path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen (path));
path += stripped;
ffc168dc: 7f ba eb 78 mr r26,r29
ffc168e0: 4b ff ff 0c b ffc167ec <rtems_rfs_rtems_eval_for_make+0xc8>
/*
* If the node is the current directory and there is more path to come move
* on it else we are at the inode we want.
*/
if (rtems_rfs_current_dir (node))
ffc168e4: 88 7a 00 01 lbz r3,1(r26) <== NOT EXECUTED
ffc168e8: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc168ec: 40 9e 01 98 bne- cr7,ffc16a84 <rtems_rfs_rtems_eval_for_make+0x360><== NOT EXECUTED
{
if (*path)
ffc168f0: 88 1d 00 00 lbz r0,0(r29) <== NOT EXECUTED
ffc168f4: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc168f8: 40 9e 01 a4 bne- cr7,ffc16a9c <rtems_rfs_rtems_eval_for_make+0x378><== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_for_make: closing node", rc);
}
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
ffc168fc: 81 21 00 20 lwz r9,32(r1)
ffc16900: 88 09 00 02 lbz r0,2(r9)
ffc16904: 54 00 44 26 rlwinm r0,r0,8,16,19
ffc16908: 2f 80 40 00 cmpwi cr7,r0,16384
ffc1690c: 40 9e 02 fc bne- cr7,ffc16c08 <rtems_rfs_rtems_eval_for_make+0x4e4>
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_for_make: not dir", ENOTDIR);
}
if (!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_WX))
ffc16910: 38 61 00 14 addi r3,r1,20
ffc16914: 38 80 00 03 li r4,3
ffc16918: 48 00 0e 05 bl ffc1771c <rtems_rfs_rtems_eval_perms>
ffc1691c: 2f 83 00 00 cmpwi cr7,r3,0
ffc16920: 41 9e 00 b4 beq- cr7,ffc169d4 <rtems_rfs_rtems_eval_for_make+0x2b0><== NEVER TAKEN
}
/*
* Make sure the name does not already exists in the directory.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, *name, strlen (*name),
ffc16924: 83 de 00 00 lwz r30,0(r30)
ffc16928: 7f c3 f3 78 mr r3,r30
ffc1692c: 48 01 51 9d bl ffc2bac8 <strlen>
ffc16930: 7f c5 f3 78 mr r5,r30
ffc16934: 7c 66 1b 78 mr r6,r3
ffc16938: 38 81 00 14 addi r4,r1,20
ffc1693c: 7f e3 fb 78 mr r3,r31
ffc16940: 38 e1 00 0c addi r7,r1,12
ffc16944: 39 01 00 08 addi r8,r1,8
ffc16948: 48 00 c7 6d bl ffc230b4 <rtems_rfs_dir_lookup_ino>
&node_ino, &doff);
if (rc == 0)
ffc1694c: 7c 7e 1b 79 mr. r30,r3
ffc16950: 41 82 03 c4 beq- ffc16d14 <rtems_rfs_rtems_eval_for_make+0x5f0>
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_for_make: found name", EEXIST);
}
if (rc != ENOENT)
ffc16954: 2f 9e 00 02 cmpwi cr7,r30,2
ffc16958: 41 9e 01 58 beq- cr7,ffc16ab0 <rtems_rfs_rtems_eval_for_make+0x38c>
{
rtems_rfs_inode_close (fs, &inode);
ffc1695c: 38 81 00 14 addi r4,r1,20
ffc16960: 7f e3 fb 78 mr r3,r31
ffc16964: 4b ff d8 d5 bl ffc14238 <rtems_rfs_inode_close>
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc16968: 83 bf 00 7c lwz r29,124(r31)
rtems_rfs_buffers_release (fs);
ffc1696c: 7f e3 fb 78 mr r3,r31
ffc16970: 48 00 c4 75 bl ffc22de4 <rtems_rfs_buffers_release>
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc16974: 80 7d 00 00 lwz r3,0(r29)
ffc16978: 4b ff 6f a1 bl ffc0d918 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc1697c: 7c 7f 1b 79 mr. r31,r3
ffc16980: 40 82 02 18 bne- ffc16b98 <rtems_rfs_rtems_eval_for_make+0x474><== NEVER TAKEN
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_for_make: look up", rc);
ffc16984: 48 01 32 dd bl ffc29c60 <__errno>
ffc16988: 93 c3 00 00 stw r30,0(r3)
ffc1698c: 3b c0 ff ff li r30,-1
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
return rc;
}
ffc16990: 80 01 00 6c lwz r0,108(r1)
ffc16994: 7f c3 f3 78 mr r3,r30
ffc16998: 83 21 00 4c lwz r25,76(r1)
ffc1699c: 7c 08 03 a6 mtlr r0
ffc169a0: 83 41 00 50 lwz r26,80(r1)
ffc169a4: 83 61 00 54 lwz r27,84(r1)
ffc169a8: 83 81 00 58 lwz r28,88(r1)
ffc169ac: 83 a1 00 5c lwz r29,92(r1)
ffc169b0: 83 c1 00 60 lwz r30,96(r1)
ffc169b4: 83 e1 00 64 lwz r31,100(r1)
ffc169b8: 38 21 00 68 addi r1,r1,104
ffc169bc: 4e 80 00 20 blr
/*
* If a directory the execute bit must be set for us to enter.
*/
if (RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)) &&
!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_SEARCH))
ffc169c0: 38 61 00 14 addi r3,r1,20
ffc169c4: 38 80 00 01 li r4,1
ffc169c8: 48 00 0d 55 bl ffc1771c <rtems_rfs_rtems_eval_perms>
}
/*
* If a directory the execute bit must be set for us to enter.
*/
if (RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)) &&
ffc169cc: 2f 83 00 00 cmpwi cr7,r3,0
ffc169d0: 40 9e fe 4c bne+ cr7,ffc1681c <rtems_rfs_rtems_eval_for_make+0xf8><== ALWAYS TAKEN
return rtems_rfs_rtems_error ("eval_for_make: not dir", ENOTDIR);
}
if (!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_WX))
{
rtems_rfs_inode_close (fs, &inode);
ffc169d4: 38 81 00 14 addi r4,r1,20 <== NOT EXECUTED
ffc169d8: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc169dc: 4b ff d8 5d bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc169e0: 83 df 00 7c lwz r30,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc169e4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc169e8: 48 00 c3 fd bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc169ec: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc169f0: 4b ff 6f 29 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc169f4: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc169f8: 40 82 02 e8 bne- ffc16ce0 <rtems_rfs_rtems_eval_for_make+0x5bc><== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_for_make: cannot write", EACCES);
ffc169fc: 48 01 32 65 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc16a00: 38 00 00 0d li r0,13 <== NOT EXECUTED
ffc16a04: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc16a08: 3b c0 ff ff li r30,-1 <== NOT EXECUTED
ffc16a0c: 4b ff ff 84 b ffc16990 <rtems_rfs_rtems_eval_for_make+0x26c><== NOT EXECUTED
/*
* If the node is a parent we must move up one directory. If the location
* is on another file system we have a crossmount so we call that file
* system to handle the remainder of the path.
*/
if (rtems_rfs_parent_dir (path))
ffc16a10: 88 7d 00 02 lbz r3,2(r29) <== NOT EXECUTED
ffc16a14: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc16a18: 40 9e 01 b4 bne- cr7,ffc16bcc <rtems_rfs_rtems_eval_for_make+0x4a8><== NOT EXECUTED
{
/*
* If we are at the root inode of the file system we have a crossmount
* path.
*/
if (ino == RTEMS_RFS_ROOT_INO)
ffc16a1c: 80 01 00 10 lwz r0,16(r1) <== NOT EXECUTED
ffc16a20: 2f 80 00 01 cmpwi cr7,r0,1 <== NOT EXECUTED
ffc16a24: 41 9e 03 2c beq- cr7,ffc16d50 <rtems_rfs_rtems_eval_for_make+0x62c><== NOT EXECUTED
/*
* If not a directory give and up return. We cannot change dir from a
* regular file or device node.
*/
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
ffc16a28: 81 21 00 20 lwz r9,32(r1) <== NOT EXECUTED
ffc16a2c: 88 09 00 02 lbz r0,2(r9) <== NOT EXECUTED
ffc16a30: 54 00 44 26 rlwinm r0,r0,8,16,19 <== NOT EXECUTED
ffc16a34: 2f 80 40 00 cmpwi cr7,r0,16384 <== NOT EXECUTED
ffc16a38: 40 9e 03 8c bne- cr7,ffc16dc4 <rtems_rfs_rtems_eval_for_make+0x6a0><== NOT EXECUTED
}
/*
* We need to find the parent of this node.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, "..", 2, &ino, &doff);
ffc16a3c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc16a40: 38 81 00 14 addi r4,r1,20 <== NOT EXECUTED
ffc16a44: 7f 65 db 78 mr r5,r27 <== NOT EXECUTED
ffc16a48: 38 c0 00 02 li r6,2 <== NOT EXECUTED
ffc16a4c: 4b ff fe 68 b ffc168b4 <rtems_rfs_rtems_eval_for_make+0x190><== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc16a50: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc16a54: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc16a58: 48 00 0f 11 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc16a5c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc16a60: 41 9e fd 84 beq+ cr7,ffc167e4 <rtems_rfs_rtems_eval_for_make+0xc0><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
ffc16a64: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc16a68: 48 00 5d d5 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc16a6c: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc16a70: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc16a74: 38 63 bb 30 addi r3,r3,-17616 <== NOT EXECUTED
ffc16a78: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc16a7c: 48 01 42 c9 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc16a80: 4b ff fd 64 b ffc167e4 <rtems_rfs_rtems_eval_for_make+0xc0><== NOT EXECUTED
/*
* If the node is the current directory and there is more path to come move
* on it else we are at the inode we want.
*/
if (rtems_rfs_current_dir (node))
ffc16a84: 4b ff 39 61 bl ffc0a3e4 <rtems_filesystem_is_separator><== NOT EXECUTED
ffc16a88: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc16a8c: 41 be fe 00 beq- cr7,ffc1688c <rtems_rfs_rtems_eval_for_make+0x168><== NOT EXECUTED
{
if (*path)
ffc16a90: 88 1d 00 00 lbz r0,0(r29) <== NOT EXECUTED
ffc16a94: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc16a98: 41 9e fe 64 beq+ cr7,ffc168fc <rtems_rfs_rtems_eval_for_make+0x1d8><== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
ffc16a9c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc16aa0: 38 81 00 14 addi r4,r1,20 <== NOT EXECUTED
ffc16aa4: 4b ff d7 95 bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
/*
* Eat any separators at start of the new path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen (path));
path += stripped;
ffc16aa8: 7f ba eb 78 mr r26,r29 <== NOT EXECUTED
ffc16aac: 4b ff fd 40 b ffc167ec <rtems_rfs_rtems_eval_for_make+0xc8><== NOT EXECUTED
/*
* Set the parent ino in the path location.
*/
rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
ffc16ab0: 80 01 00 10 lwz r0,16(r1)
rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);
rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
ffc16ab4: 38 81 00 14 addi r4,r1,20
ffc16ab8: 7f 83 e3 78 mr r3,r28
/*
* Set the parent ino in the path location.
*/
rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
ffc16abc: 90 1c 00 00 stw r0,0(r28)
rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);
ffc16ac0: 80 01 00 08 lwz r0,8(r1)
ffc16ac4: 90 1c 00 04 stw r0,4(r28)
rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
ffc16ac8: 48 00 0d 95 bl ffc1785c <rtems_rfs_rtems_set_handlers>
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
printf("rtems-rfs-rtems: eval-for-make: parent ino:%" PRId32 " name:%s\n",
ino, *name);
rtems_rfs_inode_close (fs, &inode);
ffc16acc: 38 81 00 14 addi r4,r1,20
*/
rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);
rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
ffc16ad0: 33 c3 ff ff addic r30,r3,-1
ffc16ad4: 7f de f1 10 subfe r30,r30,r30
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
printf("rtems-rfs-rtems: eval-for-make: parent ino:%" PRId32 " name:%s\n",
ino, *name);
rtems_rfs_inode_close (fs, &inode);
ffc16ad8: 7f e3 fb 78 mr r3,r31
ffc16adc: 4b ff d7 5d bl ffc14238 <rtems_rfs_inode_close>
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc16ae0: 83 bf 00 7c lwz r29,124(r31)
rtems_rfs_buffers_release (fs);
ffc16ae4: 7f e3 fb 78 mr r3,r31
ffc16ae8: 48 00 c2 fd bl ffc22de4 <rtems_rfs_buffers_release>
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc16aec: 80 7d 00 00 lwz r3,0(r29)
*/
rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);
rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
ffc16af0: 73 de 00 05 andi. r30,r30,5
ffc16af4: 4b ff 6e 25 bl ffc0d918 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc16af8: 7c 7f 1b 79 mr. r31,r3
ffc16afc: 41 82 fe 94 beq+ ffc16990 <rtems_rfs_rtems_eval_for_make+0x26c><== ALWAYS TAKEN
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc16b00: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc16b04: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc16b08: 48 00 0e 61 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc16b0c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc16b10: 41 9e fe 80 beq+ cr7,ffc16990 <rtems_rfs_rtems_eval_for_make+0x26c><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc16b14: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc16b18: 48 00 5d 25 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc16b1c: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc16b20: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc16b24: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc16b28: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc16b2c: 48 01 42 19 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc16b30: 4b ff fe 60 b ffc16990 <rtems_rfs_rtems_eval_for_make+0x26c><== NOT EXECUTED
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode,
node, node_len - stripped, &ino, &doff);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &inode);
ffc16b34: 38 81 00 14 addi r4,r1,20
ffc16b38: 7f e3 fb 78 mr r3,r31
ffc16b3c: 4b ff d6 fd bl ffc14238 <rtems_rfs_inode_close>
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc16b40: 83 df 00 7c lwz r30,124(r31)
rtems_rfs_buffers_release (fs);
ffc16b44: 7f e3 fb 78 mr r3,r31
ffc16b48: 48 00 c2 9d bl ffc22de4 <rtems_rfs_buffers_release>
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc16b4c: 80 7e 00 00 lwz r3,0(r30)
ffc16b50: 4b ff 6d c9 bl ffc0d918 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc16b54: 7c 7f 1b 79 mr. r31,r3
ffc16b58: 40 82 00 ec bne- ffc16c44 <rtems_rfs_rtems_eval_for_make+0x520><== NEVER TAKEN
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_for_make: closing node", rc);
ffc16b5c: 48 01 31 05 bl ffc29c60 <__errno>
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
return rc;
}
ffc16b60: 80 01 00 6c lwz r0,108(r1)
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_for_make: closing node", rc);
ffc16b64: 3b c0 ff ff li r30,-1
ffc16b68: 93 43 00 00 stw r26,0(r3)
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
return rc;
}
ffc16b6c: 7c 08 03 a6 mtlr r0
ffc16b70: 7f c3 f3 78 mr r3,r30
ffc16b74: 83 21 00 4c lwz r25,76(r1)
ffc16b78: 83 41 00 50 lwz r26,80(r1)
ffc16b7c: 83 61 00 54 lwz r27,84(r1)
ffc16b80: 83 81 00 58 lwz r28,88(r1)
ffc16b84: 83 a1 00 5c lwz r29,92(r1)
ffc16b88: 83 c1 00 60 lwz r30,96(r1)
ffc16b8c: 83 e1 00 64 lwz r31,100(r1)
ffc16b90: 38 21 00 68 addi r1,r1,104
ffc16b94: 4e 80 00 20 blr
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc16b98: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc16b9c: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc16ba0: 48 00 0d c9 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc16ba4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc16ba8: 41 9e fd dc beq+ cr7,ffc16984 <rtems_rfs_rtems_eval_for_make+0x260><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc16bac: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc16bb0: 48 00 5c 8d bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc16bb4: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc16bb8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc16bbc: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc16bc0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc16bc4: 48 01 41 81 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc16bc8: 4b ff fd bc b ffc16984 <rtems_rfs_rtems_eval_for_make+0x260><== NOT EXECUTED
/*
* If the node is a parent we must move up one directory. If the location
* is on another file system we have a crossmount so we call that file
* system to handle the remainder of the path.
*/
if (rtems_rfs_parent_dir (path))
ffc16bcc: 4b ff 38 19 bl ffc0a3e4 <rtems_filesystem_is_separator><== NOT EXECUTED
ffc16bd0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc16bd4: 41 be fc d0 beq- cr7,ffc168a4 <rtems_rfs_rtems_eval_for_make+0x180><== NOT EXECUTED
ffc16bd8: 4b ff fe 44 b ffc16a1c <rtems_rfs_rtems_eval_for_make+0x2f8><== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc16bdc: 83 df 00 7c lwz r30,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc16be0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc16be4: 48 00 c2 01 bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc16be8: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc16bec: 4b ff 6d 2d bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc16bf0: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc16bf4: 40 82 00 84 bne- ffc16c78 <rtems_rfs_rtems_eval_for_make+0x554><== NOT EXECUTED
*/
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
if (rc > 0)
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_for_make: read ino", rc);
ffc16bf8: 48 01 30 69 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc16bfc: 3b c0 ff ff li r30,-1 <== NOT EXECUTED
ffc16c00: 93 a3 00 00 stw r29,0(r3) <== NOT EXECUTED
ffc16c04: 4b ff fd 8c b ffc16990 <rtems_rfs_rtems_eval_for_make+0x26c><== NOT EXECUTED
}
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
{
rtems_rfs_inode_close (fs, &inode);
ffc16c08: 38 81 00 14 addi r4,r1,20
ffc16c0c: 7f e3 fb 78 mr r3,r31
ffc16c10: 4b ff d6 29 bl ffc14238 <rtems_rfs_inode_close>
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc16c14: 83 df 00 7c lwz r30,124(r31)
rtems_rfs_buffers_release (fs);
ffc16c18: 7f e3 fb 78 mr r3,r31
ffc16c1c: 48 00 c1 c9 bl ffc22de4 <rtems_rfs_buffers_release>
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc16c20: 80 7e 00 00 lwz r3,0(r30)
ffc16c24: 4b ff 6c f5 bl ffc0d918 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc16c28: 7c 7f 1b 79 mr. r31,r3
ffc16c2c: 40 82 00 80 bne- ffc16cac <rtems_rfs_rtems_eval_for_make+0x588><== NEVER TAKEN
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_for_make: not dir", ENOTDIR);
ffc16c30: 48 01 30 31 bl ffc29c60 <__errno>
ffc16c34: 38 00 00 14 li r0,20
ffc16c38: 90 03 00 00 stw r0,0(r3)
ffc16c3c: 3b c0 ff ff li r30,-1
ffc16c40: 4b ff fd 50 b ffc16990 <rtems_rfs_rtems_eval_for_make+0x26c>
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc16c44: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc16c48: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc16c4c: 48 00 0d 1d bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc16c50: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc16c54: 41 9e ff 08 beq+ cr7,ffc16b5c <rtems_rfs_rtems_eval_for_make+0x438><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc16c58: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc16c5c: 48 00 5b e1 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc16c60: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc16c64: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc16c68: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc16c6c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc16c70: 48 01 40 d5 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc16c74: 4b ff fe e8 b ffc16b5c <rtems_rfs_rtems_eval_for_make+0x438><== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc16c78: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc16c7c: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc16c80: 48 00 0c e9 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc16c84: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc16c88: 41 9e ff 70 beq+ cr7,ffc16bf8 <rtems_rfs_rtems_eval_for_make+0x4d4><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc16c8c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc16c90: 48 00 5b ad bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc16c94: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc16c98: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc16c9c: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc16ca0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc16ca4: 48 01 40 a1 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc16ca8: 4b ff ff 50 b ffc16bf8 <rtems_rfs_rtems_eval_for_make+0x4d4><== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc16cac: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc16cb0: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc16cb4: 48 00 0c b5 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc16cb8: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc16cbc: 41 9e ff 74 beq+ cr7,ffc16c30 <rtems_rfs_rtems_eval_for_make+0x50c><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc16cc0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc16cc4: 48 00 5b 79 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc16cc8: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc16ccc: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc16cd0: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc16cd4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc16cd8: 48 01 40 6d bl ffc2ad44 <printf> <== NOT EXECUTED
ffc16cdc: 4b ff ff 54 b ffc16c30 <rtems_rfs_rtems_eval_for_make+0x50c><== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc16ce0: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc16ce4: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc16ce8: 48 00 0c 81 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc16cec: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc16cf0: 41 9e fd 0c beq+ cr7,ffc169fc <rtems_rfs_rtems_eval_for_make+0x2d8><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc16cf4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc16cf8: 48 00 5b 45 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc16cfc: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc16d00: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc16d04: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc16d08: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc16d0c: 48 01 40 39 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc16d10: 4b ff fc ec b ffc169fc <rtems_rfs_rtems_eval_for_make+0x2d8><== NOT EXECUTED
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, *name, strlen (*name),
&node_ino, &doff);
if (rc == 0)
{
rtems_rfs_inode_close (fs, &inode);
ffc16d14: 38 81 00 14 addi r4,r1,20
ffc16d18: 7f e3 fb 78 mr r3,r31
ffc16d1c: 4b ff d5 1d bl ffc14238 <rtems_rfs_inode_close>
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc16d20: 83 df 00 7c lwz r30,124(r31)
rtems_rfs_buffers_release (fs);
ffc16d24: 7f e3 fb 78 mr r3,r31
ffc16d28: 48 00 c0 bd bl ffc22de4 <rtems_rfs_buffers_release>
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc16d2c: 80 7e 00 00 lwz r3,0(r30)
ffc16d30: 4b ff 6b e9 bl ffc0d918 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc16d34: 7c 7f 1b 79 mr. r31,r3
ffc16d38: 40 82 00 c8 bne- ffc16e00 <rtems_rfs_rtems_eval_for_make+0x6dc><== NEVER TAKEN
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_for_make: found name", EEXIST);
ffc16d3c: 48 01 2f 25 bl ffc29c60 <__errno>
ffc16d40: 38 00 00 11 li r0,17
ffc16d44: 90 03 00 00 stw r0,0(r3)
ffc16d48: 3b c0 ff ff li r30,-1
ffc16d4c: 4b ff fc 44 b ffc16990 <rtems_rfs_rtems_eval_for_make+0x26c>
{
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
printf("rtems-rfs-rtems: eval-for-make: crossmount: path:%s\n",
path - node_len);
rtems_rfs_inode_close (fs, &inode);
ffc16d50: 38 81 00 14 addi r4,r1,20 <== NOT EXECUTED
ffc16d54: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc16d58: 4b ff d4 e1 bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc16d5c: 83 7f 00 7c lwz r27,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc16d60: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc16d64: 48 00 c0 81 bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc16d68: 80 7b 00 00 lwz r3,0(r27) <== NOT EXECUTED
ffc16d6c: 4b ff 6b ad bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc16d70: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc16d74: 40 82 00 c0 bne- ffc16e34 <rtems_rfs_rtems_eval_for_make+0x710><== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
*pathloc = pathloc->mt_entry->mt_point_node;
ffc16d78: 81 3c 00 10 lwz r9,16(r28) <== NOT EXECUTED
return (*pathloc->ops->evalformake_h)(path + 2, pathloc, name);
ffc16d7c: 7f c5 f3 78 mr r5,r30 <== NOT EXECUTED
ffc16d80: 38 7d 00 02 addi r3,r29,2 <== NOT EXECUTED
printf("rtems-rfs-rtems: eval-for-make: crossmount: path:%s\n",
path - node_len);
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
*pathloc = pathloc->mt_entry->mt_point_node;
ffc16d84: 81 69 00 14 lwz r11,20(r9) <== NOT EXECUTED
return (*pathloc->ops->evalformake_h)(path + 2, pathloc, name);
ffc16d88: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
printf("rtems-rfs-rtems: eval-for-make: crossmount: path:%s\n",
path - node_len);
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
*pathloc = pathloc->mt_entry->mt_point_node;
ffc16d8c: 80 09 00 10 lwz r0,16(r9) <== NOT EXECUTED
ffc16d90: 81 09 00 08 lwz r8,8(r9) <== NOT EXECUTED
ffc16d94: 81 49 00 0c lwz r10,12(r9) <== NOT EXECUTED
ffc16d98: 90 1c 00 08 stw r0,8(r28) <== NOT EXECUTED
ffc16d9c: 91 1c 00 00 stw r8,0(r28) <== NOT EXECUTED
ffc16da0: 91 5c 00 04 stw r10,4(r28) <== NOT EXECUTED
ffc16da4: 91 7c 00 0c stw r11,12(r28) <== NOT EXECUTED
return (*pathloc->ops->evalformake_h)(path + 2, pathloc, name);
ffc16da8: 80 0b 00 04 lwz r0,4(r11) <== NOT EXECUTED
printf("rtems-rfs-rtems: eval-for-make: crossmount: path:%s\n",
path - node_len);
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
*pathloc = pathloc->mt_entry->mt_point_node;
ffc16dac: 81 29 00 18 lwz r9,24(r9) <== NOT EXECUTED
return (*pathloc->ops->evalformake_h)(path + 2, pathloc, name);
ffc16db0: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
printf("rtems-rfs-rtems: eval-for-make: crossmount: path:%s\n",
path - node_len);
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
*pathloc = pathloc->mt_entry->mt_point_node;
ffc16db4: 91 3c 00 10 stw r9,16(r28) <== NOT EXECUTED
return (*pathloc->ops->evalformake_h)(path + 2, pathloc, name);
ffc16db8: 4e 80 04 21 bctrl <== NOT EXECUTED
ffc16dbc: 7c 7e 1b 78 mr r30,r3 <== NOT EXECUTED
ffc16dc0: 4b ff fb d0 b ffc16990 <rtems_rfs_rtems_eval_for_make+0x26c><== NOT EXECUTED
* If not a directory give and up return. We cannot change dir from a
* regular file or device node.
*/
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
{
rtems_rfs_inode_close (fs, &inode);
ffc16dc4: 38 81 00 14 addi r4,r1,20 <== NOT EXECUTED
ffc16dc8: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc16dcc: 4b ff d4 6d bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc16dd0: 83 df 00 7c lwz r30,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc16dd4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc16dd8: 48 00 c0 0d bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc16ddc: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc16de0: 4b ff 6b 39 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc16de4: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc16de8: 40 82 00 80 bne- ffc16e68 <rtems_rfs_rtems_eval_for_make+0x744><== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_for_make: not dir", ENOTSUP);
ffc16dec: 48 01 2e 75 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc16df0: 38 00 00 86 li r0,134 <== NOT EXECUTED
ffc16df4: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc16df8: 3b c0 ff ff li r30,-1 <== NOT EXECUTED
ffc16dfc: 4b ff fb 94 b ffc16990 <rtems_rfs_rtems_eval_for_make+0x26c><== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc16e00: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc16e04: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc16e08: 48 00 0b 61 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc16e0c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc16e10: 41 9e ff 2c beq+ cr7,ffc16d3c <rtems_rfs_rtems_eval_for_make+0x618><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc16e14: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc16e18: 48 00 5a 25 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc16e1c: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc16e20: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc16e24: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc16e28: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc16e2c: 48 01 3f 19 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc16e30: 4b ff ff 0c b ffc16d3c <rtems_rfs_rtems_eval_for_make+0x618><== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc16e34: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc16e38: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc16e3c: 48 00 0b 2d bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc16e40: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc16e44: 41 9e ff 34 beq+ cr7,ffc16d78 <rtems_rfs_rtems_eval_for_make+0x654><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc16e48: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc16e4c: 48 00 59 f1 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc16e50: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc16e54: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc16e58: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc16e5c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc16e60: 48 01 3e e5 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc16e64: 4b ff ff 14 b ffc16d78 <rtems_rfs_rtems_eval_for_make+0x654><== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc16e68: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc16e6c: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc16e70: 48 00 0a f9 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc16e74: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc16e78: 41 9e ff 74 beq+ cr7,ffc16dec <rtems_rfs_rtems_eval_for_make+0x6c8><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc16e7c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc16e80: 48 00 59 bd bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc16e84: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc16e88: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc16e8c: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc16e90: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc16e94: 48 01 3e b1 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc16e98: 4b ff ff 54 b ffc16dec <rtems_rfs_rtems_eval_for_make+0x6c8><== NOT EXECUTED
ffc16e9c <rtems_rfs_rtems_eval_path>:
static int
rtems_rfs_rtems_eval_path (const char* path,
size_t pathlen,
int flags,
rtems_filesystem_location_info_t* pathloc)
{
ffc16e9c: 94 21 ff a0 stwu r1,-96(r1)
ffc16ea0: 7c 08 02 a6 mflr r0
ffc16ea4: 90 01 00 64 stw r0,100(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc16ea8: 81 26 00 10 lwz r9,16(r6)
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
ffc16eac: 80 06 00 00 lwz r0,0(r6)
static int
rtems_rfs_rtems_eval_path (const char* path,
size_t pathlen,
int flags,
rtems_filesystem_location_info_t* pathloc)
{
ffc16eb0: 93 c1 00 58 stw r30,88(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc16eb4: 83 c9 00 34 lwz r30,52(r9)
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
ffc16eb8: 90 01 00 0c stw r0,12(r1)
uint32_t doff = 0;
ffc16ebc: 38 00 00 00 li r0,0
static int
rtems_rfs_rtems_eval_path (const char* path,
size_t pathlen,
int flags,
rtems_filesystem_location_info_t* pathloc)
{
ffc16ec0: 93 21 00 44 stw r25,68(r1)
ffc16ec4: 7c 79 1b 78 mr r25,r3
ffc16ec8: 93 41 00 48 stw r26,72(r1)
ffc16ecc: 7c ba 2b 78 mr r26,r5
ffc16ed0: 93 81 00 50 stw r28,80(r1)
ffc16ed4: 7c dc 33 78 mr r28,r6
ffc16ed8: 93 a1 00 54 stw r29,84(r1)
ffc16edc: 93 e1 00 5c stw r31,92(r1)
ffc16ee0: 7c 9f 23 78 mr r31,r4
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
uint32_t doff = 0;
ffc16ee4: 90 01 00 08 stw r0,8(r1)
static int
rtems_rfs_rtems_eval_path (const char* path,
size_t pathlen,
int flags,
rtems_filesystem_location_info_t* pathloc)
{
ffc16ee8: 92 e1 00 3c stw r23,60(r1)
ffc16eec: 93 01 00 40 stw r24,64(r1)
ffc16ef0: 93 61 00 4c stw r27,76(r1)
path, pathlen, ino);
/*
* Eat any separators at the start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
ffc16ef4: 4b ff 13 bd bl ffc082b0 <rtems_filesystem_prefix_separators>
ffc16ef8: 7c 60 1b 78 mr r0,r3
rtems_rfs_mutex_destroy (&rtems->access);
free (rtems);
return rtems_rfs_rtems_error ("shutdown: close", rc);
}
ffc16efc: 81 3e 00 7c lwz r9,124(r30)
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
ffc16f00: 38 80 00 00 li r4,0
ffc16f04: 38 a0 00 00 li r5,0
ffc16f08: 80 69 00 00 lwz r3,0(r9)
/*
* Eat any separators at the start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
path += stripped;
ffc16f0c: 7f 39 02 14 add r25,r25,r0
pathlen -= stripped;
ffc16f10: 7f e0 f8 50 subf r31,r0,r31
ffc16f14: 4b ff 68 79 bl ffc0d78c <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
ffc16f18: 7c 7d 1b 79 mr. r29,r3
ffc16f1c: 40 82 02 28 bne- ffc17144 <rtems_rfs_rtems_eval_path+0x2a8><== NEVER TAKEN
}
/*
* We need to find the parent of this node.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, "..", 2, &ino, &doff);
ffc16f20: 3f 60 ff c4 lis r27,-60
ffc16f24: 3b 7b 9c b4 addi r27,r27,-25420
while (true)
{
/*
* Open and load the inode.
*/
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc16f28: 80 81 00 0c lwz r4,12(r1)
ffc16f2c: 7f c3 f3 78 mr r3,r30
ffc16f30: 38 a1 00 10 addi r5,r1,16
ffc16f34: 38 c0 00 01 li r6,1
ffc16f38: 4b ff d0 a1 bl ffc13fd8 <rtems_rfs_inode_open>
if (rc > 0)
ffc16f3c: 7c 7d 1b 79 mr. r29,r3
ffc16f40: 41 81 03 18 bgt- ffc17258 <rtems_rfs_rtems_eval_path+0x3bc><== NEVER TAKEN
}
/*
* Is this the end of the pathname we where given ?
*/
if ((*path == '\0') || (pathlen == 0))
ffc16f44: 88 79 00 00 lbz r3,0(r25)
ffc16f48: 2f 83 00 00 cmpwi cr7,r3,0
ffc16f4c: 41 9e 00 e4 beq- cr7,ffc17030 <rtems_rfs_rtems_eval_path+0x194>
ffc16f50: 2f 9f 00 00 cmpwi cr7,r31,0
ffc16f54: 41 9e 00 dc beq- cr7,ffc17030 <rtems_rfs_rtems_eval_path+0x194><== NEVER TAKEN
break;
/*
* If a directory the execute bit must be set for us to enter.
*/
if (RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)) &&
ffc16f58: 81 21 00 1c lwz r9,28(r1)
ffc16f5c: 88 09 00 02 lbz r0,2(r9)
ffc16f60: 54 00 44 26 rlwinm r0,r0,8,16,19
ffc16f64: 2f 80 40 00 cmpwi cr7,r0,16384
ffc16f68: 41 9e 01 58 beq- cr7,ffc170c0 <rtems_rfs_rtems_eval_path+0x224>
ffc16f6c: 7f 3d cb 78 mr r29,r25
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
path += stripped;
ffc16f70: 3b 00 00 00 li r24,0
ffc16f74: 48 00 00 2c b ffc16fa0 <rtems_rfs_rtems_eval_path+0x104>
/*
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator (*path) &&
ffc16f78: 89 3d 00 00 lbz r9,0(r29)
ffc16f7c: 2f 89 00 00 cmpwi cr7,r9,0
ffc16f80: 41 9e 00 34 beq- cr7,ffc16fb4 <rtems_rfs_rtems_eval_path+0x118><== NEVER TAKEN
(*path != '\0') && pathlen &&
ffc16f84: 41 9a 01 34 beq- cr6,ffc170b8 <rtems_rfs_rtems_eval_path+0x21c><== NEVER TAKEN
ffc16f88: 81 3e 00 18 lwz r9,24(r30)
ffc16f8c: 7f 80 48 40 cmplw cr7,r0,r9
ffc16f90: 40 9c 00 24 bge- cr7,ffc16fb4 <rtems_rfs_rtems_eval_path+0x118><== NEVER TAKEN
((node_len + 1) < rtems_rfs_fs_max_name (fs)))
{
path++;
pathlen--;
ffc16f94: 8c 7d 00 01 lbzu r3,1(r29)
ffc16f98: 3b ff ff ff addi r31,r31,-1
ffc16f9c: 7c 18 03 78 mr r24,r0
/*
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator (*path) &&
ffc16fa0: 4b ff 34 45 bl ffc0a3e4 <rtems_filesystem_is_separator>
(*path != '\0') && pathlen &&
((node_len + 1) < rtems_rfs_fs_max_name (fs)))
ffc16fa4: 38 18 00 01 addi r0,r24,1
/*
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator (*path) &&
ffc16fa8: 2f 83 00 00 cmpwi cr7,r3,0
(*path != '\0') && pathlen &&
ffc16fac: 2f 1f 00 00 cmpwi cr6,r31,0
/*
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator (*path) &&
ffc16fb0: 41 9e ff c8 beq+ cr7,ffc16f78 <rtems_rfs_rtems_eval_path+0xdc>
(*path != '\0') && pathlen &&
ffc16fb4: 7f e4 fb 78 mr r4,r31
}
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
ffc16fb8: 7f a3 eb 78 mr r3,r29
ffc16fbc: 4b ff 12 f5 bl ffc082b0 <rtems_filesystem_prefix_separators>
/*
* If the node is the current directory and there is more path to come move
* on it else we are at the inode we want.
*/
if (rtems_rfs_current_dir (node))
ffc16fc0: 88 19 00 00 lbz r0,0(r25)
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
path += stripped;
ffc16fc4: 7f bd 1a 14 add r29,r29,r3
/*
* If the node is the current directory and there is more path to come move
* on it else we are at the inode we want.
*/
if (rtems_rfs_current_dir (node))
ffc16fc8: 2f 80 00 2e cmpwi cr7,r0,46
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
path += stripped;
pathlen -= stripped;
ffc16fcc: 7f e3 f8 50 subf r31,r3,r31
node_len += stripped;
ffc16fd0: 7e e3 c2 14 add r23,r3,r24
/*
* If the node is the current directory and there is more path to come move
* on it else we are at the inode we want.
*/
if (rtems_rfs_current_dir (node))
ffc16fd4: 41 9e 00 44 beq- cr7,ffc17018 <rtems_rfs_rtems_eval_path+0x17c>
/*
* Look up the node name in this directory. If found drop through, close
* the current inode and let the loop open the inode so the mode can be
* read and handlers set.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode,
ffc16fd8: 7f c3 f3 78 mr r3,r30
ffc16fdc: 38 81 00 10 addi r4,r1,16
ffc16fe0: 7f 25 cb 78 mr r5,r25
ffc16fe4: 7f 06 c3 78 mr r6,r24
ffc16fe8: 38 e1 00 0c addi r7,r1,12
ffc16fec: 39 01 00 08 addi r8,r1,8
ffc16ff0: 48 00 c0 c5 bl ffc230b4 <rtems_rfs_dir_lookup_ino>
node, node_len - stripped, &ino, &doff);
if (rc > 0)
ffc16ff4: 7c 79 1b 79 mr. r25,r3
ffc16ff8: 41 81 01 e4 bgt- ffc171dc <rtems_rfs_rtems_eval_path+0x340>
}
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PATH))
printf("rtems-rfs-rtems: eval-path: down: path:%s ino:%" PRId32 "\n", node, ino);
}
rc = rtems_rfs_inode_close (fs, &inode);
ffc16ffc: 7f c3 f3 78 mr r3,r30
ffc17000: 38 81 00 10 addi r4,r1,16
ffc17004: 4b ff d2 35 bl ffc14238 <rtems_rfs_inode_close>
if (rc > 0)
ffc17008: 7c 79 1b 79 mr. r25,r3
ffc1700c: 41 81 01 d0 bgt- ffc171dc <rtems_rfs_rtems_eval_path+0x340><== NEVER TAKEN
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
path += stripped;
ffc17010: 7f b9 eb 78 mr r25,r29
ffc17014: 4b ff ff 14 b ffc16f28 <rtems_rfs_rtems_eval_path+0x8c>
/*
* If the node is the current directory and there is more path to come move
* on it else we are at the inode we want.
*/
if (rtems_rfs_current_dir (node))
ffc17018: 88 79 00 01 lbz r3,1(r25)
ffc1701c: 2f 83 00 00 cmpwi cr7,r3,0
ffc17020: 40 9e 01 58 bne- cr7,ffc17178 <rtems_rfs_rtems_eval_path+0x2dc>
{
if (*path)
ffc17024: 88 1d 00 00 lbz r0,0(r29)
ffc17028: 2f 80 00 00 cmpwi cr7,r0,0
ffc1702c: 40 9e 01 9c bne- cr7,ffc171c8 <rtems_rfs_rtems_eval_path+0x32c><== NEVER TAKEN
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_path: closing node", rc);
}
}
rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
ffc17030: 80 01 00 0c lwz r0,12(r1)
rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);
rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
ffc17034: 38 81 00 10 addi r4,r1,16
ffc17038: 7f 83 e3 78 mr r3,r28
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_path: closing node", rc);
}
}
rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
ffc1703c: 90 1c 00 00 stw r0,0(r28)
rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);
ffc17040: 80 01 00 08 lwz r0,8(r1)
ffc17044: 90 1c 00 04 stw r0,4(r28)
rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
ffc17048: 48 00 08 15 bl ffc1785c <rtems_rfs_rtems_set_handlers>
rtems_rfs_inode_close (fs, &inode);
ffc1704c: 38 81 00 10 addi r4,r1,16
}
rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);
rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
ffc17050: 33 e3 ff ff addic r31,r3,-1
ffc17054: 7f ff f9 10 subfe r31,r31,r31
rtems_rfs_inode_close (fs, &inode);
ffc17058: 7f c3 f3 78 mr r3,r30
ffc1705c: 4b ff d1 dd bl ffc14238 <rtems_rfs_inode_close>
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc17060: 83 be 00 7c lwz r29,124(r30)
rtems_rfs_buffers_release (fs);
ffc17064: 7f c3 f3 78 mr r3,r30
ffc17068: 48 00 bd 7d bl ffc22de4 <rtems_rfs_buffers_release>
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc1706c: 80 7d 00 00 lwz r3,0(r29)
}
rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);
rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
ffc17070: 73 ff 00 05 andi. r31,r31,5
ffc17074: 4b ff 68 a5 bl ffc0d918 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc17078: 7c 7e 1b 79 mr. r30,r3
ffc1707c: 40 82 00 60 bne- ffc170dc <rtems_rfs_rtems_eval_path+0x240><== NEVER TAKEN
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PATH))
printf("rtems-rfs-rtems: eval-path: ino:%" PRId32 "\n", ino);
return rc;
}
ffc17080: 80 01 00 64 lwz r0,100(r1)
ffc17084: 7f e3 fb 78 mr r3,r31
ffc17088: 82 e1 00 3c lwz r23,60(r1)
ffc1708c: 7c 08 03 a6 mtlr r0
ffc17090: 83 01 00 40 lwz r24,64(r1)
ffc17094: 83 21 00 44 lwz r25,68(r1)
ffc17098: 83 41 00 48 lwz r26,72(r1)
ffc1709c: 83 61 00 4c lwz r27,76(r1)
ffc170a0: 83 81 00 50 lwz r28,80(r1)
ffc170a4: 83 a1 00 54 lwz r29,84(r1)
ffc170a8: 83 c1 00 58 lwz r30,88(r1)
ffc170ac: 83 e1 00 5c lwz r31,92(r1)
ffc170b0: 38 21 00 60 addi r1,r1,96
ffc170b4: 4e 80 00 20 blr
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator (*path) &&
(*path != '\0') && pathlen &&
ffc170b8: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc170bc: 4b ff fe fc b ffc16fb8 <rtems_rfs_rtems_eval_path+0x11c><== NOT EXECUTED
/*
* If a directory the execute bit must be set for us to enter.
*/
if (RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)) &&
!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_SEARCH))
ffc170c0: 38 61 00 10 addi r3,r1,16
ffc170c4: 38 80 00 01 li r4,1
ffc170c8: 48 00 06 55 bl ffc1771c <rtems_rfs_rtems_eval_perms>
break;
/*
* If a directory the execute bit must be set for us to enter.
*/
if (RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)) &&
ffc170cc: 2f 83 00 00 cmpwi cr7,r3,0
ffc170d0: 41 9e 02 94 beq- cr7,ffc17364 <rtems_rfs_rtems_eval_path+0x4c8><== NEVER TAKEN
ffc170d4: 88 79 00 00 lbz r3,0(r25)
ffc170d8: 4b ff fe 94 b ffc16f6c <rtems_rfs_rtems_eval_path+0xd0>
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc170dc: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc170e0: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc170e4: 48 00 08 85 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc170e8: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc170ec: 41 9e ff 94 beq+ cr7,ffc17080 <rtems_rfs_rtems_eval_path+0x1e4><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc170f0: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc170f4: 48 00 57 49 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc170f8: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc170fc: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc17100: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc17104: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc17108: 48 01 3c 3d bl ffc2ad44 <printf> <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PATH))
printf("rtems-rfs-rtems: eval-path: ino:%" PRId32 "\n", ino);
return rc;
}
ffc1710c: 80 01 00 64 lwz r0,100(r1) <== NOT EXECUTED
ffc17110: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc17114: 82 e1 00 3c lwz r23,60(r1) <== NOT EXECUTED
ffc17118: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc1711c: 83 01 00 40 lwz r24,64(r1) <== NOT EXECUTED
ffc17120: 83 21 00 44 lwz r25,68(r1) <== NOT EXECUTED
ffc17124: 83 41 00 48 lwz r26,72(r1) <== NOT EXECUTED
ffc17128: 83 61 00 4c lwz r27,76(r1) <== NOT EXECUTED
ffc1712c: 83 81 00 50 lwz r28,80(r1) <== NOT EXECUTED
ffc17130: 83 a1 00 54 lwz r29,84(r1) <== NOT EXECUTED
ffc17134: 83 c1 00 58 lwz r30,88(r1) <== NOT EXECUTED
ffc17138: 83 e1 00 5c lwz r31,92(r1) <== NOT EXECUTED
ffc1713c: 38 21 00 60 addi r1,r1,96 <== NOT EXECUTED
ffc17140: 4e 80 00 20 blr <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc17144: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc17148: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc1714c: 48 00 08 1d bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc17150: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc17154: 41 9e fd cc beq+ cr7,ffc16f20 <rtems_rfs_rtems_eval_path+0x84><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
ffc17158: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc1715c: 48 00 56 e1 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc17160: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc17164: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc17168: 38 63 bb 30 addi r3,r3,-17616 <== NOT EXECUTED
ffc1716c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc17170: 48 01 3b d5 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc17174: 4b ff fd ac b ffc16f20 <rtems_rfs_rtems_eval_path+0x84><== NOT EXECUTED
/*
* If the node is the current directory and there is more path to come move
* on it else we are at the inode we want.
*/
if (rtems_rfs_current_dir (node))
ffc17178: 4b ff 32 6d bl ffc0a3e4 <rtems_filesystem_is_separator>
ffc1717c: 2f 83 00 00 cmpwi cr7,r3,0
ffc17180: 40 be fe a4 bne- cr7,ffc17024 <rtems_rfs_rtems_eval_path+0x188><== NEVER TAKEN
/*
* If the node is a parent we must move up one directory. If the location
* is on another file system we have a crossmount so we call that file
* system to handle the remainder of the path.
*/
if (rtems_rfs_parent_dir (node))
ffc17184: 88 19 00 00 lbz r0,0(r25)
ffc17188: 2f 80 00 2e cmpwi cr7,r0,46
ffc1718c: 40 be fe 4c bne- cr7,ffc16fd8 <rtems_rfs_rtems_eval_path+0x13c><== NEVER TAKEN
ffc17190: 88 19 00 01 lbz r0,1(r25)
ffc17194: 2f 80 00 2e cmpwi cr7,r0,46
ffc17198: 40 9e fe 40 bne+ cr7,ffc16fd8 <rtems_rfs_rtems_eval_path+0x13c><== NEVER TAKEN
ffc1719c: 88 79 00 02 lbz r3,2(r25)
ffc171a0: 2f 83 00 00 cmpwi cr7,r3,0
ffc171a4: 40 9e 00 a4 bne- cr7,ffc17248 <rtems_rfs_rtems_eval_path+0x3ac><== NEVER TAKEN
{
/*
* If we are at root inode of the file system we have a crossmount path.
*/
if (ino == RTEMS_RFS_ROOT_INO)
ffc171a8: 80 01 00 0c lwz r0,12(r1)
ffc171ac: 2f 80 00 01 cmpwi cr7,r0,1
ffc171b0: 41 9e 01 3c beq- cr7,ffc172ec <rtems_rfs_rtems_eval_path+0x450>
}
/*
* We need to find the parent of this node.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, "..", 2, &ino, &doff);
ffc171b4: 7f c3 f3 78 mr r3,r30
ffc171b8: 38 81 00 10 addi r4,r1,16
ffc171bc: 7f 65 db 78 mr r5,r27
ffc171c0: 38 c0 00 02 li r6,2
ffc171c4: 4b ff fe 24 b ffc16fe8 <rtems_rfs_rtems_eval_path+0x14c>
*/
if (rtems_rfs_current_dir (node))
{
if (*path)
{
rtems_rfs_inode_close (fs, &inode);
ffc171c8: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc171cc: 38 81 00 10 addi r4,r1,16 <== NOT EXECUTED
ffc171d0: 4b ff d0 69 bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
path += stripped;
ffc171d4: 7f b9 eb 78 mr r25,r29 <== NOT EXECUTED
ffc171d8: 4b ff fd 50 b ffc16f28 <rtems_rfs_rtems_eval_path+0x8c><== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &inode);
ffc171dc: 38 81 00 10 addi r4,r1,16
ffc171e0: 7f c3 f3 78 mr r3,r30
ffc171e4: 4b ff d0 55 bl ffc14238 <rtems_rfs_inode_close>
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc171e8: 83 fe 00 7c lwz r31,124(r30)
rtems_rfs_buffers_release (fs);
ffc171ec: 7f c3 f3 78 mr r3,r30
ffc171f0: 48 00 bb f5 bl ffc22de4 <rtems_rfs_buffers_release>
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc171f4: 80 7f 00 00 lwz r3,0(r31)
ffc171f8: 4b ff 67 21 bl ffc0d918 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc171fc: 7c 7f 1b 79 mr. r31,r3
ffc17200: 40 82 00 84 bne- ffc17284 <rtems_rfs_rtems_eval_path+0x3e8><== NEVER TAKEN
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_path: closing node", rc);
ffc17204: 48 01 2a 5d bl ffc29c60 <__errno>
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PATH))
printf("rtems-rfs-rtems: eval-path: ino:%" PRId32 "\n", ino);
return rc;
}
ffc17208: 80 01 00 64 lwz r0,100(r1)
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_path: closing node", rc);
ffc1720c: 3b e0 ff ff li r31,-1
ffc17210: 93 23 00 00 stw r25,0(r3)
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PATH))
printf("rtems-rfs-rtems: eval-path: ino:%" PRId32 "\n", ino);
return rc;
}
ffc17214: 7c 08 03 a6 mtlr r0
ffc17218: 7f e3 fb 78 mr r3,r31
ffc1721c: 82 e1 00 3c lwz r23,60(r1)
ffc17220: 83 01 00 40 lwz r24,64(r1)
ffc17224: 83 21 00 44 lwz r25,68(r1)
ffc17228: 83 41 00 48 lwz r26,72(r1)
ffc1722c: 83 61 00 4c lwz r27,76(r1)
ffc17230: 83 81 00 50 lwz r28,80(r1)
ffc17234: 83 a1 00 54 lwz r29,84(r1)
ffc17238: 83 c1 00 58 lwz r30,88(r1)
ffc1723c: 83 e1 00 5c lwz r31,92(r1)
ffc17240: 38 21 00 60 addi r1,r1,96
ffc17244: 4e 80 00 20 blr
/*
* If the node is a parent we must move up one directory. If the location
* is on another file system we have a crossmount so we call that file
* system to handle the remainder of the path.
*/
if (rtems_rfs_parent_dir (node))
ffc17248: 4b ff 31 9d bl ffc0a3e4 <rtems_filesystem_is_separator><== NOT EXECUTED
ffc1724c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc17250: 41 be fd 88 beq- cr7,ffc16fd8 <rtems_rfs_rtems_eval_path+0x13c><== NOT EXECUTED
ffc17254: 4b ff ff 54 b ffc171a8 <rtems_rfs_rtems_eval_path+0x30c><== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc17258: 83 fe 00 7c lwz r31,124(r30) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc1725c: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc17260: 48 00 bb 85 bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc17264: 80 7f 00 00 lwz r3,0(r31) <== NOT EXECUTED
ffc17268: 4b ff 66 b1 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc1726c: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc17270: 40 82 00 48 bne- ffc172b8 <rtems_rfs_rtems_eval_path+0x41c><== NOT EXECUTED
*/
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
if (rc > 0)
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_path: opening inode", rc);
ffc17274: 48 01 29 ed bl ffc29c60 <__errno> <== NOT EXECUTED
ffc17278: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc1727c: 93 a3 00 00 stw r29,0(r3) <== NOT EXECUTED
ffc17280: 4b ff fe 00 b ffc17080 <rtems_rfs_rtems_eval_path+0x1e4><== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc17284: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc17288: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc1728c: 48 00 06 dd bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc17290: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc17294: 41 9e ff 70 beq+ cr7,ffc17204 <rtems_rfs_rtems_eval_path+0x368><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc17298: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1729c: 48 00 55 a1 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc172a0: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc172a4: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc172a8: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc172ac: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc172b0: 48 01 3a 95 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc172b4: 4b ff ff 50 b ffc17204 <rtems_rfs_rtems_eval_path+0x368><== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc172b8: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc172bc: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc172c0: 48 00 06 a9 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc172c4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc172c8: 41 9e ff ac beq+ cr7,ffc17274 <rtems_rfs_rtems_eval_path+0x3d8><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc172cc: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc172d0: 48 00 55 6d bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc172d4: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc172d8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc172dc: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc172e0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc172e4: 48 01 3a 61 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc172e8: 4b ff ff 8c b ffc17274 <rtems_rfs_rtems_eval_path+0x3d8><== NOT EXECUTED
if (ino == RTEMS_RFS_ROOT_INO)
{
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PATH))
printf("rtems-rfs-rtems: eval-path: crossmount: path:%s (%zd)\n",
path - node_len, pathlen + node_len);
rtems_rfs_inode_close (fs, &inode);
ffc172ec: 38 81 00 10 addi r4,r1,16
ffc172f0: 7f c3 f3 78 mr r3,r30
ffc172f4: 4b ff cf 45 bl ffc14238 <rtems_rfs_inode_close>
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc172f8: 83 7e 00 7c lwz r27,124(r30)
rtems_rfs_buffers_release (fs);
ffc172fc: 7f c3 f3 78 mr r3,r30
ffc17300: 48 00 ba e5 bl ffc22de4 <rtems_rfs_buffers_release>
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc17304: 80 7b 00 00 lwz r3,0(r27)
ffc17308: 4b ff 66 11 bl ffc0d918 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc1730c: 7c 7e 1b 79 mr. r30,r3
ffc17310: 40 82 00 90 bne- ffc173a0 <rtems_rfs_rtems_eval_path+0x504><== NEVER TAKEN
rtems_rfs_rtems_unlock (fs);
*pathloc = pathloc->mt_entry->mt_point_node;
ffc17314: 81 3c 00 10 lwz r9,16(r28)
return (*pathloc->ops->evalpath_h)(path - node_len, pathlen + node_len,
ffc17318: 7c 97 fa 14 add r4,r23,r31
ffc1731c: 7c 77 e8 50 subf r3,r23,r29
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PATH))
printf("rtems-rfs-rtems: eval-path: crossmount: path:%s (%zd)\n",
path - node_len, pathlen + node_len);
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
*pathloc = pathloc->mt_entry->mt_point_node;
ffc17320: 81 69 00 14 lwz r11,20(r9)
return (*pathloc->ops->evalpath_h)(path - node_len, pathlen + node_len,
ffc17324: 7f 45 d3 78 mr r5,r26
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PATH))
printf("rtems-rfs-rtems: eval-path: crossmount: path:%s (%zd)\n",
path - node_len, pathlen + node_len);
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
*pathloc = pathloc->mt_entry->mt_point_node;
ffc17328: 80 09 00 10 lwz r0,16(r9)
return (*pathloc->ops->evalpath_h)(path - node_len, pathlen + node_len,
ffc1732c: 7f 86 e3 78 mr r6,r28
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PATH))
printf("rtems-rfs-rtems: eval-path: crossmount: path:%s (%zd)\n",
path - node_len, pathlen + node_len);
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
*pathloc = pathloc->mt_entry->mt_point_node;
ffc17330: 81 09 00 08 lwz r8,8(r9)
ffc17334: 81 49 00 0c lwz r10,12(r9)
ffc17338: 90 1c 00 08 stw r0,8(r28)
ffc1733c: 91 1c 00 00 stw r8,0(r28)
ffc17340: 91 5c 00 04 stw r10,4(r28)
ffc17344: 91 7c 00 0c stw r11,12(r28)
return (*pathloc->ops->evalpath_h)(path - node_len, pathlen + node_len,
ffc17348: 80 0b 00 00 lwz r0,0(r11)
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PATH))
printf("rtems-rfs-rtems: eval-path: crossmount: path:%s (%zd)\n",
path - node_len, pathlen + node_len);
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
*pathloc = pathloc->mt_entry->mt_point_node;
ffc1734c: 81 29 00 18 lwz r9,24(r9)
return (*pathloc->ops->evalpath_h)(path - node_len, pathlen + node_len,
ffc17350: 7c 09 03 a6 mtctr r0
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PATH))
printf("rtems-rfs-rtems: eval-path: crossmount: path:%s (%zd)\n",
path - node_len, pathlen + node_len);
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
*pathloc = pathloc->mt_entry->mt_point_node;
ffc17354: 91 3c 00 10 stw r9,16(r28)
return (*pathloc->ops->evalpath_h)(path - node_len, pathlen + node_len,
ffc17358: 4e 80 04 21 bctrl
ffc1735c: 7c 7f 1b 78 mr r31,r3
ffc17360: 4b ff fd 20 b ffc17080 <rtems_rfs_rtems_eval_path+0x1e4>
* If a directory the execute bit must be set for us to enter.
*/
if (RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)) &&
!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_SEARCH))
{
rtems_rfs_inode_close (fs, &inode);
ffc17364: 38 81 00 10 addi r4,r1,16 <== NOT EXECUTED
ffc17368: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1736c: 4b ff ce cd bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc17370: 83 fe 00 7c lwz r31,124(r30) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc17374: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc17378: 48 00 ba 6d bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc1737c: 80 7f 00 00 lwz r3,0(r31) <== NOT EXECUTED
ffc17380: 4b ff 65 99 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc17384: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc17388: 40 82 00 4c bne- ffc173d4 <rtems_rfs_rtems_eval_path+0x538><== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_path: eval perms", EACCES);
ffc1738c: 48 01 28 d5 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc17390: 38 00 00 0d li r0,13 <== NOT EXECUTED
ffc17394: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc17398: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc1739c: 4b ff fc e4 b ffc17080 <rtems_rfs_rtems_eval_path+0x1e4><== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc173a0: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc173a4: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc173a8: 48 00 05 c1 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc173ac: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc173b0: 41 9e ff 64 beq+ cr7,ffc17314 <rtems_rfs_rtems_eval_path+0x478><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc173b4: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc173b8: 48 00 54 85 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc173bc: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc173c0: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc173c4: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc173c8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc173cc: 48 01 39 79 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc173d0: 4b ff ff 44 b ffc17314 <rtems_rfs_rtems_eval_path+0x478><== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc173d4: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc173d8: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc173dc: 48 00 05 8d bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc173e0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc173e4: 41 9e ff a8 beq+ cr7,ffc1738c <rtems_rfs_rtems_eval_path+0x4f0><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc173e8: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc173ec: 48 00 54 51 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc173f0: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc173f4: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc173f8: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc173fc: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc17400: 48 01 39 45 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc17404: 4b ff ff 88 b ffc1738c <rtems_rfs_rtems_eval_path+0x4f0><== NOT EXECUTED
ffc1771c <rtems_rfs_rtems_eval_perms>:
#include "rtems-rfs-rtems.h"
bool
rtems_rfs_rtems_eval_perms (rtems_rfs_inode_handle* inode, int flags)
{
ffc1771c: 94 21 ff d8 stwu r1,-40(r1)
ffc17720: 7c 08 02 a6 mflr r0
ffc17724: 90 01 00 2c stw r0,44(r1)
ffc17728: 93 c1 00 20 stw r30,32(r1)
{
/*
* Mapping matches RTEMS so no need to change.
*/
return imode;
}
ffc1772c: 81 23 00 0c lwz r9,12(r3)
#include "rtems-rfs-rtems.h"
bool
rtems_rfs_rtems_eval_perms (rtems_rfs_inode_handle* inode, int flags)
{
ffc17730: 93 e1 00 24 stw r31,36(r1)
ffc17734: 7c 9f 23 78 mr r31,r4
ffc17738: 93 21 00 0c stw r25,12(r1)
ffc1773c: 93 41 00 10 stw r26,16(r1)
ffc17740: 93 61 00 14 stw r27,20(r1)
ffc17744: 93 81 00 18 stw r28,24(r1)
ffc17748: 93 a1 00 1c stw r29,28(r1)
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
ffc1774c: 8b a9 00 02 lbz r29,2(r9)
ffc17750: 88 09 00 03 lbz r0,3(r9)
ffc17754: 57 bd 40 2e rlwinm r29,r29,8,0,23
* @return uint16_t The user id (uid).
*/
static inline uint16_t
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;
ffc17758: 8b 29 00 06 lbz r25,6(r9)
ffc1775c: 8b 49 00 07 lbz r26,7(r9)
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
ffc17760: 7f bd 03 78 or r29,r29,r0
* @return uint16_t The group id (gid).
*/
static inline uint16_t
rtems_rfs_inode_get_gid (rtems_rfs_inode_handle* handle)
{
return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;
ffc17764: 8b 69 00 04 lbz r27,4(r9)
ffc17768: 8b 89 00 05 lbz r28,5(r9)
uid = rtems_rfs_inode_get_uid (inode);
gid = rtems_rfs_inode_get_gid (inode);
mode = rtems_rfs_inode_get_mode (inode);
#if defined (RTEMS_POSIX_API)
st_uid = geteuid ();
ffc1776c: 48 00 55 41 bl ffc1ccac <geteuid>
ffc17770: 7c 7e 1b 78 mr r30,r3
st_gid = getegid ();
ffc17774: 48 00 55 29 bl ffc1cc9c <getegid>
/*
* Check if I am owner or a group member or someone else.
*/
flags_to_test = flags;
if ((st_uid == 0) || (st_uid == uid))
ffc17778: 2f 9e 00 00 cmpwi cr7,r30,0
flags_to_test |= flags << 6;
ffc1777c: 57 e9 30 32 rlwinm r9,r31,6,0,25
ffc17780: 7d 20 fb 78 or r0,r9,r31
/*
* Check if I am owner or a group member or someone else.
*/
flags_to_test = flags;
if ((st_uid == 0) || (st_uid == uid))
ffc17784: 41 9e 00 70 beq- cr7,ffc177f4 <rtems_rfs_rtems_eval_perms+0xd8><== ALWAYS TAKEN
* @return uint16_t The user id (uid).
*/
static inline uint16_t
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;
ffc17788: 57 39 40 2e rlwinm r25,r25,8,0,23 <== NOT EXECUTED
ffc1778c: 7f 5a cb 78 or r26,r26,r25 <== NOT EXECUTED
ffc17790: 7f 9e d0 00 cmpw cr7,r30,r26 <== NOT EXECUTED
#endif
/*
* Check if I am owner or a group member or someone else.
*/
flags_to_test = flags;
ffc17794: 7f e0 fb 78 mr r0,r31 <== NOT EXECUTED
if ((st_uid == 0) || (st_uid == uid))
ffc17798: 41 9e 00 a4 beq- cr7,ffc1783c <rtems_rfs_rtems_eval_perms+0x120><== NOT EXECUTED
* @return uint16_t The group id (gid).
*/
static inline uint16_t
rtems_rfs_inode_get_gid (rtems_rfs_inode_handle* handle)
{
return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;
ffc1779c: 57 7b c0 0e rlwinm r27,r27,24,0,7 <== NOT EXECUTED
ffc177a0: 57 9c 80 1e rlwinm r28,r28,16,0,15 <== NOT EXECUTED
ffc177a4: 7f 7c e3 78 or r28,r27,r28 <== NOT EXECUTED
flags_to_test |= flags << 6;
if ((st_uid == 0) || (st_gid == gid))
ffc177a8: 57 9c 84 3e rlwinm r28,r28,16,16,31 <== NOT EXECUTED
ffc177ac: 7f 83 e0 00 cmpw cr7,r3,r28 <== NOT EXECUTED
ffc177b0: 41 9e 00 44 beq- cr7,ffc177f4 <rtems_rfs_rtems_eval_perms+0xd8><== NOT EXECUTED
/*
* If all of the flags are set we have permission
* to do this.
*/
if ((flags_to_test & (mode & 0777)) != 0)
ffc177b4: 57 bd 05 fe clrlwi r29,r29,23 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PERMS))
printf("rtems-rfs: eval-perms: perms failed\n");
return false;
}
ffc177b8: 83 21 00 0c lwz r25,12(r1) <== NOT EXECUTED
#include <stdlib.h>
#include "rtems-rfs-rtems.h"
bool
rtems_rfs_rtems_eval_perms (rtems_rfs_inode_handle* inode, int flags)
ffc177bc: 7f a9 00 39 and. r9,r29,r0 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PERMS))
printf("rtems-rfs: eval-perms: perms failed\n");
return false;
}
ffc177c0: 80 01 00 2c lwz r0,44(r1) <== NOT EXECUTED
ffc177c4: 83 41 00 10 lwz r26,16(r1) <== NOT EXECUTED
ffc177c8: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc177cc: 83 61 00 14 lwz r27,20(r1) <== NOT EXECUTED
#include <stdlib.h>
#include "rtems-rfs-rtems.h"
bool
rtems_rfs_rtems_eval_perms (rtems_rfs_inode_handle* inode, int flags)
ffc177d0: 7c 60 00 26 mfcr r3 <== NOT EXECUTED
ffc177d4: 54 63 1f fe rlwinm r3,r3,3,31,31 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PERMS))
printf("rtems-rfs: eval-perms: perms failed\n");
return false;
}
ffc177d8: 83 81 00 18 lwz r28,24(r1) <== NOT EXECUTED
ffc177dc: 83 a1 00 1c lwz r29,28(r1) <== NOT EXECUTED
ffc177e0: 68 63 00 01 xori r3,r3,1 <== NOT EXECUTED
ffc177e4: 83 c1 00 20 lwz r30,32(r1) <== NOT EXECUTED
ffc177e8: 83 e1 00 24 lwz r31,36(r1) <== NOT EXECUTED
ffc177ec: 38 21 00 28 addi r1,r1,40 <== NOT EXECUTED
ffc177f0: 4e 80 00 20 blr <== NOT EXECUTED
flags_to_test = flags;
if ((st_uid == 0) || (st_uid == uid))
flags_to_test |= flags << 6;
if ((st_uid == 0) || (st_gid == gid))
flags_to_test |= flags << 3;
ffc177f4: 57 ff 18 38 rlwinm r31,r31,3,0,28
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PERMS))
printf("rtems-rfs: eval-perms: perms failed\n");
return false;
}
ffc177f8: 83 21 00 0c lwz r25,12(r1)
flags_to_test = flags;
if ((st_uid == 0) || (st_uid == uid))
flags_to_test |= flags << 6;
if ((st_uid == 0) || (st_gid == gid))
flags_to_test |= flags << 3;
ffc177fc: 7c 00 fb 78 or r0,r0,r31
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PERMS))
printf("rtems-rfs: eval-perms: perms failed\n");
return false;
}
ffc17800: 83 41 00 10 lwz r26,16(r1)
/*
* If all of the flags are set we have permission
* to do this.
*/
if ((flags_to_test & (mode & 0777)) != 0)
ffc17804: 57 bd 05 fe clrlwi r29,r29,23
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PERMS))
printf("rtems-rfs: eval-perms: perms failed\n");
return false;
}
ffc17808: 83 61 00 14 lwz r27,20(r1)
#include <stdlib.h>
#include "rtems-rfs-rtems.h"
bool
rtems_rfs_rtems_eval_perms (rtems_rfs_inode_handle* inode, int flags)
ffc1780c: 7f a9 00 39 and. r9,r29,r0
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PERMS))
printf("rtems-rfs: eval-perms: perms failed\n");
return false;
}
ffc17810: 80 01 00 2c lwz r0,44(r1)
ffc17814: 83 81 00 18 lwz r28,24(r1)
ffc17818: 7c 08 03 a6 mtlr r0
ffc1781c: 83 a1 00 1c lwz r29,28(r1)
#include <stdlib.h>
#include "rtems-rfs-rtems.h"
bool
rtems_rfs_rtems_eval_perms (rtems_rfs_inode_handle* inode, int flags)
ffc17820: 7c 60 00 26 mfcr r3
ffc17824: 54 63 1f fe rlwinm r3,r3,3,31,31
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PERMS))
printf("rtems-rfs: eval-perms: perms failed\n");
return false;
}
ffc17828: 83 c1 00 20 lwz r30,32(r1)
ffc1782c: 83 e1 00 24 lwz r31,36(r1)
ffc17830: 38 21 00 28 addi r1,r1,40
ffc17834: 68 63 00 01 xori r3,r3,1
ffc17838: 4e 80 00 20 blr
ffc1783c: 57 7b c0 0e rlwinm r27,r27,24,0,7 <== NOT EXECUTED
ffc17840: 57 9c 80 1e rlwinm r28,r28,16,0,15 <== NOT EXECUTED
ffc17844: 7f 7c e3 78 or r28,r27,r28 <== NOT EXECUTED
*/
flags_to_test = flags;
if ((st_uid == 0) || (st_uid == uid))
flags_to_test |= flags << 6;
if ((st_uid == 0) || (st_gid == gid))
ffc17848: 57 9c 84 3e rlwinm r28,r28,16,16,31 <== NOT EXECUTED
ffc1784c: 7f 83 e0 00 cmpw cr7,r3,r28 <== NOT EXECUTED
* Check if I am owner or a group member or someone else.
*/
flags_to_test = flags;
if ((st_uid == 0) || (st_uid == uid))
flags_to_test |= flags << 6;
ffc17850: 7d 20 fb 78 or r0,r9,r31 <== NOT EXECUTED
if ((st_uid == 0) || (st_gid == gid))
ffc17854: 40 9e ff 60 bne+ cr7,ffc177b4 <rtems_rfs_rtems_eval_perms+0x98><== NOT EXECUTED
ffc17858: 4b ff ff 9c b ffc177f4 <rtems_rfs_rtems_eval_perms+0xd8><== NOT EXECUTED
ffc17408 <rtems_rfs_rtems_fchmod>:
}
int
rtems_rfs_rtems_fchmod (rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
ffc17408: 94 21 ff b8 stwu r1,-72(r1) <== NOT EXECUTED
ffc1740c: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc17410: 7c 69 1b 78 mr r9,r3 <== NOT EXECUTED
ffc17414: 90 01 00 4c stw r0,76(r1) <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
ffc17418: 38 a0 00 00 li r5,0 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc1741c: 81 63 00 10 lwz r11,16(r3) <== NOT EXECUTED
}
int
rtems_rfs_rtems_fchmod (rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
ffc17420: 93 e1 00 44 stw r31,68(r1) <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc17424: 83 eb 00 34 lwz r31,52(r11) <== NOT EXECUTED
}
int
rtems_rfs_rtems_fchmod (rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
ffc17428: 93 c1 00 40 stw r30,64(r1) <== NOT EXECUTED
ffc1742c: 7c 9e 23 78 mr r30,r4 <== NOT EXECUTED
ffc17430: 38 80 00 00 li r4,0 <== NOT EXECUTED
rtems_rfs_mutex_destroy (&rtems->access);
free (rtems);
return rtems_rfs_rtems_error ("shutdown: close", rc);
}
ffc17434: 81 7f 00 7c lwz r11,124(r31) <== NOT EXECUTED
}
int
rtems_rfs_rtems_fchmod (rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
ffc17438: 93 81 00 38 stw r28,56(r1) <== NOT EXECUTED
ffc1743c: 80 6b 00 00 lwz r3,0(r11) <== NOT EXECUTED
ffc17440: 93 a1 00 3c stw r29,60(r1) <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
ffc17444: 83 a9 00 00 lwz r29,0(r9) <== NOT EXECUTED
ffc17448: 4b ff 63 45 bl ffc0d78c <rtems_semaphore_obtain> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc1744c: 7c 7c 1b 79 mr. r28,r3 <== NOT EXECUTED
ffc17450: 40 82 01 24 bne- ffc17574 <rtems_rfs_rtems_fchmod+0x16c><== NOT EXECUTED
printf ("rtems-rfs-rtems: fchmod: in: ino:%" PRId32 " mode:%06" PRIomode_t "\n",
ino, mode);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc17454: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc17458: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1745c: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
ffc17460: 38 c0 00 01 li r6,1 <== NOT EXECUTED
ffc17464: 4b ff cb 75 bl ffc13fd8 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
ffc17468: 7c 7d 1b 79 mr. r29,r3 <== NOT EXECUTED
ffc1746c: 41 82 00 50 beq- ffc174bc <rtems_rfs_rtems_fchmod+0xb4> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc17470: 83 df 00 7c lwz r30,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc17474: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc17478: 48 00 b9 6d bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc1747c: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc17480: 4b ff 64 99 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc17484: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc17488: 40 82 01 20 bne- ffc175a8 <rtems_rfs_rtems_fchmod+0x1a0><== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("fchmod: opening inode", rc);
ffc1748c: 48 01 27 d5 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc17490: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc17494: 93 a3 00 00 stw r29,0(r3) <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
ffc17498: 80 01 00 4c lwz r0,76(r1) <== NOT EXECUTED
ffc1749c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc174a0: 83 81 00 38 lwz r28,56(r1) <== NOT EXECUTED
ffc174a4: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc174a8: 83 a1 00 3c lwz r29,60(r1) <== NOT EXECUTED
ffc174ac: 83 c1 00 40 lwz r30,64(r1) <== NOT EXECUTED
ffc174b0: 83 e1 00 44 lwz r31,68(r1) <== NOT EXECUTED
ffc174b4: 38 21 00 48 addi r1,r1,72 <== NOT EXECUTED
ffc174b8: 4e 80 00 20 blr <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("fchmod: opening inode", rc);
}
imode = rtems_rfs_inode_get_mode (&inode);
ffc174bc: 81 21 00 14 lwz r9,20(r1) <== NOT EXECUTED
ffc174c0: 8b a9 00 02 lbz r29,2(r9) <== NOT EXECUTED
/*
* Verify I am the owner of the node or the super user.
*/
#if defined (RTEMS_POSIX_API)
uid = geteuid();
ffc174c4: 48 00 57 e9 bl ffc1ccac <geteuid> <== NOT EXECUTED
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
ffc174c8: 81 21 00 14 lwz r9,20(r1) <== NOT EXECUTED
* @return uint16_t The user id (uid).
*/
static inline uint16_t
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;
ffc174cc: 88 09 00 06 lbz r0,6(r9) <== NOT EXECUTED
ffc174d0: 89 69 00 07 lbz r11,7(r9) <== NOT EXECUTED
ffc174d4: 54 00 40 2e rlwinm r0,r0,8,0,23 <== NOT EXECUTED
ffc174d8: 7c 00 5b 78 or r0,r0,r11 <== NOT EXECUTED
ffc174dc: 54 00 04 3e clrlwi r0,r0,16 <== NOT EXECUTED
ffc174e0: 7f 83 00 00 cmpw cr7,r3,r0 <== NOT EXECUTED
ffc174e4: 41 9e 00 0c beq- cr7,ffc174f0 <rtems_rfs_rtems_fchmod+0xe8><== NOT EXECUTED
ffc174e8: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc174ec: 40 9e 01 78 bne- cr7,ffc17664 <rtems_rfs_rtems_fchmod+0x25c><== NOT EXECUTED
return rtems_rfs_rtems_error ("fchmod: checking uid", EPERM);
}
#endif
imode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
ffc174f0: 57 de 05 3e clrlwi r30,r30,20 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("fchmod: checking uid", EPERM);
}
#endif
imode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
ffc174f4: 57 bd 44 26 rlwinm r29,r29,8,16,19 <== NOT EXECUTED
imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
ffc174f8: 7f be f3 78 or r30,r29,r30 <== NOT EXECUTED
* @prarm mode The mode.
*/
static inline void
rtems_rfs_inode_set_mode (rtems_rfs_inode_handle* handle, uint16_t mode)
{
rtems_rfs_write_u16 (&handle->node->mode, mode);
ffc174fc: 57 c0 c2 3e rlwinm r0,r30,24,8,31 <== NOT EXECUTED
ffc17500: 98 09 00 02 stb r0,2(r9) <== NOT EXECUTED
rtems_rfs_inode_set_mode (&inode, imode);
rc = rtems_rfs_inode_close (fs, &inode);
ffc17504: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc17508: 38 00 00 01 li r0,1 <== NOT EXECUTED
* @prarm mode The mode.
*/
static inline void
rtems_rfs_inode_set_mode (rtems_rfs_inode_handle* handle, uint16_t mode)
{
rtems_rfs_write_u16 (&handle->node->mode, mode);
ffc1750c: 81 21 00 14 lwz r9,20(r1) <== NOT EXECUTED
ffc17510: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc17514: 9b c9 00 03 stb r30,3(r9) <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc17518: 98 01 00 18 stb r0,24(r1) <== NOT EXECUTED
ffc1751c: 4b ff cd 1d bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
ffc17520: 7c 7e 1b 79 mr. r30,r3 <== NOT EXECUTED
ffc17524: 40 81 00 ec ble- ffc17610 <rtems_rfs_rtems_fchmod+0x208><== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc17528: 83 bf 00 7c lwz r29,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc1752c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc17530: 48 00 b8 b5 bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc17534: 80 7d 00 00 lwz r3,0(r29) <== NOT EXECUTED
ffc17538: 4b ff 63 e1 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc1753c: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc17540: 40 82 00 9c bne- ffc175dc <rtems_rfs_rtems_fchmod+0x1d4><== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("fchmod: closing inode", rc);
ffc17544: 48 01 27 1d bl ffc29c60 <__errno> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
ffc17548: 80 01 00 4c lwz r0,76(r1) <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("fchmod: closing inode", rc);
ffc1754c: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc17550: 93 c3 00 00 stw r30,0(r3) <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
ffc17554: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc17558: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1755c: 83 81 00 38 lwz r28,56(r1) <== NOT EXECUTED
ffc17560: 83 a1 00 3c lwz r29,60(r1) <== NOT EXECUTED
ffc17564: 83 c1 00 40 lwz r30,64(r1) <== NOT EXECUTED
ffc17568: 83 e1 00 44 lwz r31,68(r1) <== NOT EXECUTED
ffc1756c: 38 21 00 48 addi r1,r1,72 <== NOT EXECUTED
ffc17570: 4e 80 00 20 blr <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc17574: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc17578: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc1757c: 48 00 03 ed bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc17580: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc17584: 41 9e fe d0 beq+ cr7,ffc17454 <rtems_rfs_rtems_fchmod+0x4c><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
ffc17588: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc1758c: 48 00 52 b1 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc17590: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc17594: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc17598: 38 63 bb 30 addi r3,r3,-17616 <== NOT EXECUTED
ffc1759c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc175a0: 48 01 37 a5 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc175a4: 4b ff fe b0 b ffc17454 <rtems_rfs_rtems_fchmod+0x4c> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc175a8: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc175ac: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc175b0: 48 00 03 b9 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc175b4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc175b8: 41 9e fe d4 beq+ cr7,ffc1748c <rtems_rfs_rtems_fchmod+0x84><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc175bc: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc175c0: 48 00 52 7d bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc175c4: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc175c8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc175cc: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc175d0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc175d4: 48 01 37 71 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc175d8: 4b ff fe b4 b ffc1748c <rtems_rfs_rtems_fchmod+0x84> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc175dc: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc175e0: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc175e4: 48 00 03 85 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc175e8: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc175ec: 41 9e ff 58 beq+ cr7,ffc17544 <rtems_rfs_rtems_fchmod+0x13c><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc175f0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc175f4: 48 00 52 49 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc175f8: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc175fc: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc17600: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc17604: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc17608: 48 01 37 3d bl ffc2ad44 <printf> <== NOT EXECUTED
ffc1760c: 4b ff ff 38 b ffc17544 <rtems_rfs_rtems_fchmod+0x13c><== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc17610: 83 df 00 7c lwz r30,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc17614: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc17618: 48 00 b7 cd bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
return rtems_rfs_rtems_error ("fchmod: closing inode", rc);
}
rtems_rfs_rtems_unlock (fs);
return 0;
ffc1761c: 3b e0 00 00 li r31,0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc17620: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc17624: 4b ff 62 f5 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc17628: 7c 7e 1b 79 mr. r30,r3 <== NOT EXECUTED
ffc1762c: 41 82 fe 6c beq+ ffc17498 <rtems_rfs_rtems_fchmod+0x90> <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc17630: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc17634: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc17638: 48 00 03 31 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc1763c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc17640: 41 9e fe 58 beq+ cr7,ffc17498 <rtems_rfs_rtems_fchmod+0x90><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc17644: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc17648: 48 00 51 f5 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc1764c: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc17650: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc17654: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc17658: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1765c: 48 01 36 e9 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc17660: 4b ff fe 38 b ffc17498 <rtems_rfs_rtems_fchmod+0x90> <== NOT EXECUTED
#if defined (RTEMS_POSIX_API)
uid = geteuid();
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
{
rtems_rfs_inode_close (fs, &inode);
ffc17664: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc17668: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1766c: 4b ff cb cd bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc17670: 83 df 00 7c lwz r30,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc17674: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc17678: 48 00 b7 6d bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc1767c: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc17680: 4b ff 62 99 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc17684: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc17688: 40 82 00 18 bne- ffc176a0 <rtems_rfs_rtems_fchmod+0x298><== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("fchmod: checking uid", EPERM);
ffc1768c: 48 01 25 d5 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc17690: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc17694: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc17698: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc1769c: 4b ff fd fc b ffc17498 <rtems_rfs_rtems_fchmod+0x90> <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc176a0: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc176a4: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc176a8: 48 00 02 c1 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc176ac: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc176b0: 41 9e ff dc beq+ cr7,ffc1768c <rtems_rfs_rtems_fchmod+0x284><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc176b4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc176b8: 48 00 51 85 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc176bc: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc176c0: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc176c4: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc176c8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc176cc: 48 01 36 79 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc176d0: 4b ff ff bc b ffc1768c <rtems_rfs_rtems_fchmod+0x284><== NOT EXECUTED
ffc176d4 <rtems_rfs_rtems_fdatasync>:
* @param iop
* @return int
*/
int
rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)
{
ffc176d4: 94 21 ff f0 stwu r1,-16(r1) <== NOT EXECUTED
ffc176d8: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc176dc: 90 01 00 14 stw r0,20(r1) <== NOT EXECUTED
int rc;
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
ffc176e0: 81 23 00 2c lwz r9,44(r3) <== NOT EXECUTED
* @param iop
* @return int
*/
int
rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)
{
ffc176e4: 93 e1 00 0c stw r31,12(r1) <== NOT EXECUTED
int rc;
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
ffc176e8: 80 69 00 34 lwz r3,52(r9) <== NOT EXECUTED
ffc176ec: 48 00 b6 19 bl ffc22d04 <rtems_rfs_buffer_sync> <== NOT EXECUTED
if (rc)
ffc176f0: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
return 0;
ffc176f4: 38 60 00 00 li r3,0 <== NOT EXECUTED
rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)
{
int rc;
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
if (rc)
ffc176f8: 41 a2 00 10 beq+ ffc17708 <rtems_rfs_rtems_fdatasync+0x34><== NOT EXECUTED
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
ffc176fc: 48 01 25 65 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc17700: 93 e3 00 00 stw r31,0(r3) <== NOT EXECUTED
ffc17704: 38 60 ff ff li r3,-1 <== NOT EXECUTED
return 0;
}
ffc17708: 80 01 00 14 lwz r0,20(r1) <== NOT EXECUTED
ffc1770c: 83 e1 00 0c lwz r31,12(r1) <== NOT EXECUTED
ffc17710: 38 21 00 10 addi r1,r1,16 <== NOT EXECUTED
ffc17714: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc17718: 4e 80 00 20 blr <== NOT EXECUTED
ffc27fd4 <rtems_rfs_rtems_file_close>:
* @param iop
* @return int
*/
static int
rtems_rfs_rtems_file_close (rtems_libio_t* iop)
{
ffc27fd4: 94 21 ff e8 stwu r1,-24(r1)
ffc27fd8: 7c 08 02 a6 mflr r0
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
ffc27fdc: 38 80 00 00 li r4,0
ffc27fe0: 90 01 00 1c stw r0,28(r1)
ffc27fe4: 38 a0 00 00 li r5,0
ffc27fe8: 93 c1 00 10 stw r30,16(r1)
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
ffc27fec: 83 c3 00 20 lwz r30,32(r3)
* @param iop
* @return int
*/
static int
rtems_rfs_rtems_file_close (rtems_libio_t* iop)
{
ffc27ff0: 93 e1 00 14 stw r31,20(r1)
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
rtems_rfs_file_system* fs = rtems_rfs_file_fs (file);
ffc27ff4: 81 3e 00 1c lwz r9,28(r30)
* @param iop
* @return int
*/
static int
rtems_rfs_rtems_file_close (rtems_libio_t* iop)
{
ffc27ff8: 93 a1 00 0c stw r29,12(r1)
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
rtems_rfs_file_system* fs = rtems_rfs_file_fs (file);
ffc27ffc: 83 e9 00 98 lwz r31,152(r9)
.fpathconf_h = rtems_filesystem_default_fpathconf,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl,
.rmnod_h = rtems_rfs_rtems_rmnod
};
ffc28000: 81 3f 00 7c lwz r9,124(r31)
ffc28004: 80 69 00 00 lwz r3,0(r9)
ffc28008: 4b fe 57 85 bl ffc0d78c <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
ffc2800c: 7c 7d 1b 79 mr. r29,r3
ffc28010: 40 82 00 60 bne- ffc28070 <rtems_rfs_rtems_file_close+0x9c><== NEVER TAKEN
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_CLOSE))
printf("rtems-rfs: file-close: handle:%p\n", file);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_file_close (fs, file);
ffc28014: 7f c4 f3 78 mr r4,r30
ffc28018: 7f e3 fb 78 mr r3,r31
ffc2801c: 4b ff ca fd bl ffc24b18 <rtems_rfs_file_close>
if (rc > 0)
ffc28020: 7c 7e 1b 79 mr. r30,r3
ffc28024: 40 81 00 10 ble- ffc28034 <rtems_rfs_rtems_file_close+0x60><== ALWAYS TAKEN
rc = rtems_rfs_rtems_error ("file-close: file close", rc);
ffc28028: 48 00 1c 39 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc2802c: 93 c3 00 00 stw r30,0(r3) <== NOT EXECUTED
ffc28030: 3b c0 ff ff li r30,-1 <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc28034: 83 bf 00 7c lwz r29,124(r31)
rtems_rfs_buffers_release (fs);
ffc28038: 7f e3 fb 78 mr r3,r31
ffc2803c: 4b ff ad a9 bl ffc22de4 <rtems_rfs_buffers_release>
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc28040: 80 7d 00 00 lwz r3,0(r29)
ffc28044: 4b fe 58 d5 bl ffc0d918 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc28048: 7c 7f 1b 79 mr. r31,r3
ffc2804c: 40 82 00 58 bne- ffc280a4 <rtems_rfs_rtems_file_close+0xd0><== NEVER TAKEN
rtems_rfs_rtems_unlock (fs);
return rc;
}
ffc28050: 80 01 00 1c lwz r0,28(r1)
ffc28054: 7f c3 f3 78 mr r3,r30
ffc28058: 83 a1 00 0c lwz r29,12(r1)
ffc2805c: 7c 08 03 a6 mtlr r0
ffc28060: 83 c1 00 10 lwz r30,16(r1)
ffc28064: 83 e1 00 14 lwz r31,20(r1)
ffc28068: 38 21 00 18 addi r1,r1,24
ffc2806c: 4e 80 00 20 blr
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc28070: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc28074: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc28078: 4b fe f8 f1 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc2807c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc28080: 41 9e ff 94 beq+ cr7,ffc28014 <rtems_rfs_rtems_file_close+0x40><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
ffc28084: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc28088: 4b ff 47 b5 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc2808c: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc28090: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc28094: 38 63 bb 30 addi r3,r3,-17616 <== NOT EXECUTED
ffc28098: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc2809c: 48 00 2c a9 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc280a0: 4b ff ff 74 b ffc28014 <rtems_rfs_rtems_file_close+0x40><== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc280a4: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc280a8: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc280ac: 4b fe f8 bd bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc280b0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc280b4: 41 9e ff 9c beq+ cr7,ffc28050 <rtems_rfs_rtems_file_close+0x7c><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc280b8: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc280bc: 4b ff 47 81 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc280c0: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc280c4: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc280c8: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc280cc: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc280d0: 48 00 2c 75 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc280d4: 80 01 00 1c lwz r0,28(r1) <== NOT EXECUTED
ffc280d8: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc280dc: 83 a1 00 0c lwz r29,12(r1) <== NOT EXECUTED
ffc280e0: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc280e4: 83 c1 00 10 lwz r30,16(r1) <== NOT EXECUTED
ffc280e8: 83 e1 00 14 lwz r31,20(r1) <== NOT EXECUTED
ffc280ec: 38 21 00 18 addi r1,r1,24 <== NOT EXECUTED
ffc280f0: 4e 80 00 20 blr <== NOT EXECUTED
ffc27e70 <rtems_rfs_rtems_file_ftruncate>:
* @return int
*/
static int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
rtems_off64_t length)
{
ffc27e70: 94 21 ff e0 stwu r1,-32(r1)
ffc27e74: 7c 08 02 a6 mflr r0
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
ffc27e78: 38 80 00 00 li r4,0
ffc27e7c: 90 01 00 24 stw r0,36(r1)
ffc27e80: 93 e1 00 1c stw r31,28(r1)
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
ffc27e84: 83 e3 00 20 lwz r31,32(r3)
* @return int
*/
static int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
rtems_off64_t length)
{
ffc27e88: 93 c1 00 18 stw r30,24(r1)
ffc27e8c: 7c 7e 1b 78 mr r30,r3
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_FTRUNC))
printf("rtems-rfs: file-ftrunc: handle:%p length:%Ld\n", file, length);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
ffc27e90: 81 3f 00 1c lwz r9,28(r31)
* @return int
*/
static int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
rtems_off64_t length)
{
ffc27e94: 93 81 00 10 stw r28,16(r1)
ffc27e98: 7c bc 2b 78 mr r28,r5
ffc27e9c: 38 a0 00 00 li r5,0
.fpathconf_h = rtems_filesystem_default_fpathconf,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl,
.rmnod_h = rtems_rfs_rtems_rmnod
};
ffc27ea0: 81 29 00 98 lwz r9,152(r9)
* @return int
*/
static int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
rtems_off64_t length)
{
ffc27ea4: 93 61 00 0c stw r27,12(r1)
.fpathconf_h = rtems_filesystem_default_fpathconf,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl,
.rmnod_h = rtems_rfs_rtems_rmnod
};
ffc27ea8: 81 29 00 7c lwz r9,124(r9)
* @return int
*/
static int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
rtems_off64_t length)
{
ffc27eac: 93 a1 00 14 stw r29,20(r1)
ffc27eb0: 7c dd 33 78 mr r29,r6
ffc27eb4: 80 69 00 00 lwz r3,0(r9)
ffc27eb8: 4b fe 58 d5 bl ffc0d78c <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
ffc27ebc: 7c 7b 1b 79 mr. r27,r3
ffc27ec0: 40 82 00 88 bne- ffc27f48 <rtems_rfs_rtems_file_ftruncate+0xd8><== NEVER TAKEN
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_FTRUNC))
printf("rtems-rfs: file-ftrunc: handle:%p length:%Ld\n", file, length);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
rc = rtems_rfs_file_set_size (file, length);
ffc27ec4: 7f 85 e3 78 mr r5,r28
ffc27ec8: 7f e3 fb 78 mr r3,r31
ffc27ecc: 7f a6 eb 78 mr r6,r29
ffc27ed0: 4b ff d6 85 bl ffc25554 <rtems_rfs_file_set_size>
if (rc)
ffc27ed4: 7c 7c 1b 79 mr. r28,r3
ffc27ed8: 41 a2 00 10 beq+ ffc27ee8 <rtems_rfs_rtems_file_ftruncate+0x78><== ALWAYS TAKEN
rc = rtems_rfs_rtems_error ("file_ftruncate: set size", rc);
ffc27edc: 48 00 1d 85 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc27ee0: 93 83 00 00 stw r28,0(r3) <== NOT EXECUTED
ffc27ee4: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
iop->size = rtems_rfs_file_size (file);
ffc27ee8: 80 9f 00 1c lwz r4,28(r31)
ffc27eec: 80 64 00 98 lwz r3,152(r4)
ffc27ef0: 38 84 00 84 addi r4,r4,132
ffc27ef4: 4b ff 96 0d bl ffc21500 <rtems_rfs_block_get_size>
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
ffc27ef8: 81 3f 00 1c lwz r9,28(r31)
rc = rtems_rfs_file_set_size (file, length);
if (rc)
rc = rtems_rfs_rtems_error ("file_ftruncate: set size", rc);
iop->size = rtems_rfs_file_size (file);
ffc27efc: 90 7e 00 08 stw r3,8(r30)
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
ffc27f00: 80 69 00 98 lwz r3,152(r9)
rc = rtems_rfs_file_set_size (file, length);
if (rc)
rc = rtems_rfs_rtems_error ("file_ftruncate: set size", rc);
iop->size = rtems_rfs_file_size (file);
ffc27f04: 90 9e 00 0c stw r4,12(r30)
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc27f08: 83 e3 00 7c lwz r31,124(r3)
rtems_rfs_buffers_release (fs);
ffc27f0c: 4b ff ae d9 bl ffc22de4 <rtems_rfs_buffers_release>
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc27f10: 80 7f 00 00 lwz r3,0(r31)
ffc27f14: 4b fe 5a 05 bl ffc0d918 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc27f18: 7c 7f 1b 79 mr. r31,r3
ffc27f1c: 40 82 00 60 bne- ffc27f7c <rtems_rfs_rtems_file_ftruncate+0x10c><== NEVER TAKEN
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rc;
}
ffc27f20: 80 01 00 24 lwz r0,36(r1)
ffc27f24: 7f 83 e3 78 mr r3,r28
ffc27f28: 83 61 00 0c lwz r27,12(r1)
ffc27f2c: 7c 08 03 a6 mtlr r0
ffc27f30: 83 81 00 10 lwz r28,16(r1)
ffc27f34: 83 a1 00 14 lwz r29,20(r1)
ffc27f38: 83 c1 00 18 lwz r30,24(r1)
ffc27f3c: 83 e1 00 1c lwz r31,28(r1)
ffc27f40: 38 21 00 20 addi r1,r1,32
ffc27f44: 4e 80 00 20 blr
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc27f48: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc27f4c: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc27f50: 4b fe fa 19 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc27f54: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc27f58: 41 9e ff 6c beq+ cr7,ffc27ec4 <rtems_rfs_rtems_file_ftruncate+0x54><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
ffc27f5c: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc27f60: 4b ff 48 dd bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc27f64: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc27f68: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc27f6c: 38 63 bb 30 addi r3,r3,-17616 <== NOT EXECUTED
ffc27f70: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc27f74: 48 00 2d d1 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc27f78: 4b ff ff 4c b ffc27ec4 <rtems_rfs_rtems_file_ftruncate+0x54><== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc27f7c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc27f80: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc27f84: 4b fe f9 e5 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc27f88: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc27f8c: 41 9e ff 94 beq+ cr7,ffc27f20 <rtems_rfs_rtems_file_ftruncate+0xb0><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc27f90: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc27f94: 4b ff 48 a9 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc27f98: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc27f9c: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc27fa0: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc27fa4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc27fa8: 48 00 2d 9d bl ffc2ad44 <printf> <== NOT EXECUTED
ffc27fac: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
ffc27fb0: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc27fb4: 83 61 00 0c lwz r27,12(r1) <== NOT EXECUTED
ffc27fb8: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc27fbc: 83 81 00 10 lwz r28,16(r1) <== NOT EXECUTED
ffc27fc0: 83 a1 00 14 lwz r29,20(r1) <== NOT EXECUTED
ffc27fc4: 83 c1 00 18 lwz r30,24(r1) <== NOT EXECUTED
ffc27fc8: 83 e1 00 1c lwz r31,28(r1) <== NOT EXECUTED
ffc27fcc: 38 21 00 20 addi r1,r1,32 <== NOT EXECUTED
ffc27fd0: 4e 80 00 20 blr <== NOT EXECUTED
ffc27bf4 <rtems_rfs_rtems_file_ioctl>:
static int
rtems_rfs_rtems_file_ioctl (rtems_libio_t* iop, uint32_t command, void* buffer)
{
return 0;
}
ffc27bf4: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc27bf8: 4e 80 00 20 blr <== NOT EXECUTED
ffc283fc <rtems_rfs_rtems_file_lseek>:
*/
static rtems_off64_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
rtems_off64_t offset,
int whence)
{
ffc283fc: 94 21 ff d8 stwu r1,-40(r1)
ffc28400: 7c 08 02 a6 mflr r0
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
ffc28404: 38 80 00 00 li r4,0
ffc28408: 90 01 00 2c stw r0,44(r1)
ffc2840c: 38 a0 00 00 li r5,0
ffc28410: 93 e1 00 24 stw r31,36(r1)
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
ffc28414: 83 e3 00 20 lwz r31,32(r3)
*/
static rtems_off64_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
rtems_off64_t offset,
int whence)
{
ffc28418: 93 c1 00 20 stw r30,32(r1)
ffc2841c: 7c 7e 1b 78 mr r30,r3
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_LSEEK))
printf("rtems-rfs: file-lseek: handle:%p offset:%Ld\n", file, offset);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
ffc28420: 81 3f 00 1c lwz r9,28(r31)
*/
static rtems_off64_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
rtems_off64_t offset,
int whence)
{
ffc28424: 93 a1 00 1c stw r29,28(r1)
.fpathconf_h = rtems_filesystem_default_fpathconf,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl,
.rmnod_h = rtems_rfs_rtems_rmnod
};
ffc28428: 81 29 00 98 lwz r9,152(r9)
ffc2842c: 81 29 00 7c lwz r9,124(r9)
ffc28430: 80 69 00 00 lwz r3,0(r9)
ffc28434: 4b fe 53 59 bl ffc0d78c <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
ffc28438: 7c 7d 1b 79 mr. r29,r3
ffc2843c: 40 82 00 ac bne- ffc284e8 <rtems_rfs_rtems_file_lseek+0xec><== NEVER TAKEN
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_LSEEK))
printf("rtems-rfs: file-lseek: handle:%p offset:%Ld\n", file, offset);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
ffc28440: 80 be 00 10 lwz r5,16(r30)
ffc28444: 7c 27 0b 78 mr r7,r1
ffc28448: 80 de 00 14 lwz r6,20(r30)
rc = rtems_rfs_file_seek (file, pos, &pos);
ffc2844c: 7f e3 fb 78 mr r3,r31
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_LSEEK))
printf("rtems-rfs: file-lseek: handle:%p offset:%Ld\n", file, offset);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
ffc28450: 94 a7 00 08 stwu r5,8(r7)
ffc28454: 90 c7 00 04 stw r6,4(r7)
rc = rtems_rfs_file_seek (file, pos, &pos);
ffc28458: 4b ff d0 09 bl ffc25460 <rtems_rfs_file_seek>
if (rc)
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
ffc2845c: 81 3f 00 1c lwz r9,28(r31)
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
rc = rtems_rfs_file_seek (file, pos, &pos);
if (rc)
ffc28460: 7c 7d 1b 79 mr. r29,r3
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
ffc28464: 80 69 00 98 lwz r3,152(r9)
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc28468: 83 e3 00 7c lwz r31,124(r3)
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
rc = rtems_rfs_file_seek (file, pos, &pos);
if (rc)
ffc2846c: 41 82 00 44 beq- ffc284b0 <rtems_rfs_rtems_file_lseek+0xb4><== ALWAYS TAKEN
rtems_rfs_buffers_release (fs);
ffc28470: 4b ff a9 75 bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc28474: 80 7f 00 00 lwz r3,0(r31) <== NOT EXECUTED
ffc28478: 4b fe 54 a1 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc2847c: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc28480: 40 82 00 d0 bne- ffc28550 <rtems_rfs_rtems_file_lseek+0x154><== NOT EXECUTED
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file_lseek: lseek", rc);
ffc28484: 48 00 17 dd bl ffc29c60 <__errno> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return iop->offset;
}
ffc28488: 80 01 00 2c lwz r0,44(r1) <== NOT EXECUTED
rc = rtems_rfs_file_seek (file, pos, &pos);
if (rc)
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file_lseek: lseek", rc);
ffc2848c: 93 a3 00 00 stw r29,0(r3) <== NOT EXECUTED
ffc28490: 38 80 ff ff li r4,-1 <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return iop->offset;
}
ffc28494: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
rc = rtems_rfs_file_seek (file, pos, &pos);
if (rc)
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file_lseek: lseek", rc);
ffc28498: 38 60 ff ff li r3,-1 <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return iop->offset;
}
ffc2849c: 83 a1 00 1c lwz r29,28(r1) <== NOT EXECUTED
ffc284a0: 83 c1 00 20 lwz r30,32(r1) <== NOT EXECUTED
ffc284a4: 83 e1 00 24 lwz r31,36(r1) <== NOT EXECUTED
ffc284a8: 38 21 00 28 addi r1,r1,40 <== NOT EXECUTED
ffc284ac: 4e 80 00 20 blr <== NOT EXECUTED
ffc284b0: 4b ff a9 35 bl ffc22de4 <rtems_rfs_buffers_release>
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc284b4: 80 7f 00 00 lwz r3,0(r31)
ffc284b8: 4b fe 54 61 bl ffc0d918 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc284bc: 7c 7f 1b 79 mr. r31,r3
ffc284c0: 40 82 00 5c bne- ffc2851c <rtems_rfs_rtems_file_lseek+0x120><== NEVER TAKEN
ffc284c4: 80 01 00 2c lwz r0,44(r1)
return rtems_rfs_rtems_error ("file_lseek: lseek", rc);
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return iop->offset;
ffc284c8: 80 7e 00 10 lwz r3,16(r30)
}
ffc284cc: 7c 08 03 a6 mtlr r0
return rtems_rfs_rtems_error ("file_lseek: lseek", rc);
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return iop->offset;
ffc284d0: 80 9e 00 14 lwz r4,20(r30)
}
ffc284d4: 83 a1 00 1c lwz r29,28(r1)
ffc284d8: 83 c1 00 20 lwz r30,32(r1)
ffc284dc: 83 e1 00 24 lwz r31,36(r1)
ffc284e0: 38 21 00 28 addi r1,r1,40
ffc284e4: 4e 80 00 20 blr
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc284e8: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc284ec: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc284f0: 4b fe f4 79 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc284f4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc284f8: 41 9e ff 48 beq+ cr7,ffc28440 <rtems_rfs_rtems_file_lseek+0x44><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
ffc284fc: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc28500: 4b ff 43 3d bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc28504: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc28508: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc2850c: 38 63 bb 30 addi r3,r3,-17616 <== NOT EXECUTED
ffc28510: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc28514: 48 00 28 31 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc28518: 4b ff ff 28 b ffc28440 <rtems_rfs_rtems_file_lseek+0x44><== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc2851c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc28520: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc28524: 4b fe f4 45 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc28528: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc2852c: 41 9e ff 98 beq+ cr7,ffc284c4 <rtems_rfs_rtems_file_lseek+0xc8><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc28530: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc28534: 4b ff 43 09 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc28538: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc2853c: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc28540: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc28544: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc28548: 48 00 27 fd bl ffc2ad44 <printf> <== NOT EXECUTED
ffc2854c: 4b ff ff 78 b ffc284c4 <rtems_rfs_rtems_file_lseek+0xc8><== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc28550: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc28554: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc28558: 4b fe f4 11 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc2855c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc28560: 41 9e ff 24 beq+ cr7,ffc28484 <rtems_rfs_rtems_file_lseek+0x88><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc28564: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc28568: 4b ff 42 d5 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc2856c: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc28570: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc28574: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc28578: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc2857c: 48 00 27 c9 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc28580: 4b ff ff 04 b ffc28484 <rtems_rfs_rtems_file_lseek+0x88><== NOT EXECUTED
ffc28584 <rtems_rfs_rtems_file_open>:
static int
rtems_rfs_rtems_file_open (rtems_libio_t* iop,
const char* pathname,
uint32_t flag,
uint32_t mode)
{
ffc28584: 94 21 ff d8 stwu r1,-40(r1)
ffc28588: 7c 08 02 a6 mflr r0
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
ffc2858c: 38 80 00 00 li r4,0
ffc28590: 90 01 00 2c stw r0,44(r1)
ffc28594: 38 a0 00 00 li r5,0
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
ffc28598: 81 23 00 2c lwz r9,44(r3)
static int
rtems_rfs_rtems_file_open (rtems_libio_t* iop,
const char* pathname,
uint32_t flag,
uint32_t mode)
{
ffc2859c: 93 e1 00 24 stw r31,36(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
ffc285a0: 83 e9 00 34 lwz r31,52(r9)
static int
rtems_rfs_rtems_file_open (rtems_libio_t* iop,
const char* pathname,
uint32_t flag,
uint32_t mode)
{
ffc285a4: 93 c1 00 20 stw r30,32(r1)
ffc285a8: 7c 7e 1b 78 mr r30,r3
.fpathconf_h = rtems_filesystem_default_fpathconf,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl,
.rmnod_h = rtems_rfs_rtems_rmnod
};
ffc285ac: 81 3f 00 7c lwz r9,124(r31)
static int
rtems_rfs_rtems_file_open (rtems_libio_t* iop,
const char* pathname,
uint32_t flag,
uint32_t mode)
{
ffc285b0: 93 a1 00 1c stw r29,28(r1)
ffc285b4: 80 69 00 00 lwz r3,0(r9)
ffc285b8: 4b fe 51 d5 bl ffc0d78c <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
ffc285bc: 7c 7d 1b 79 mr. r29,r3
ffc285c0: 40 82 00 9c bne- ffc2865c <rtems_rfs_rtems_file_open+0xd8><== NEVER TAKEN
rtems_rfs_rtems_lock (fs);
ino = rtems_rfs_rtems_get_iop_ino (iop);
rc = rtems_rfs_file_open (fs, ino, flags, &file);
ffc285c4: 80 9e 00 1c lwz r4,28(r30)
ffc285c8: 7f e3 fb 78 mr r3,r31
ffc285cc: 38 a0 00 00 li r5,0
ffc285d0: 38 c1 00 08 addi r6,r1,8
ffc285d4: 4b ff c1 a1 bl ffc24774 <rtems_rfs_file_open>
if (rc > 0)
ffc285d8: 7c 7d 1b 79 mr. r29,r3
ffc285dc: 40 81 00 cc ble- ffc286a8 <rtems_rfs_rtems_file_open+0x124><== ALWAYS TAKEN
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc285e0: 83 df 00 7c lwz r30,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc285e4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc285e8: 4b ff a7 fd bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc285ec: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc285f0: 4b fe 53 29 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc285f4: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc285f8: 40 82 00 30 bne- ffc28628 <rtems_rfs_rtems_file_open+0xa4><== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("file-open: open", rc);
ffc285fc: 48 00 16 65 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc28600: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc28604: 93 a3 00 00 stw r29,0(r3) <== NOT EXECUTED
iop->size = rtems_rfs_file_size (file);
rtems_rfs_rtems_set_iop_file_handle (iop, file);
rtems_rfs_rtems_unlock (fs);
return 0;
}
ffc28608: 80 01 00 2c lwz r0,44(r1)
ffc2860c: 7f e3 fb 78 mr r3,r31
ffc28610: 83 a1 00 1c lwz r29,28(r1)
ffc28614: 7c 08 03 a6 mtlr r0
ffc28618: 83 c1 00 20 lwz r30,32(r1)
ffc2861c: 83 e1 00 24 lwz r31,36(r1)
ffc28620: 38 21 00 28 addi r1,r1,40
ffc28624: 4e 80 00 20 blr
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc28628: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc2862c: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc28630: 4b fe f3 39 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc28634: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc28638: 41 9e ff c4 beq+ cr7,ffc285fc <rtems_rfs_rtems_file_open+0x78><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc2863c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc28640: 4b ff 41 fd bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc28644: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc28648: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc2864c: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc28650: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc28654: 48 00 26 f1 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc28658: 4b ff ff a4 b ffc285fc <rtems_rfs_rtems_file_open+0x78><== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc2865c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc28660: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc28664: 4b fe f3 05 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc28668: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc2866c: 41 9e ff 58 beq+ cr7,ffc285c4 <rtems_rfs_rtems_file_open+0x40><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
ffc28670: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc28674: 4b ff 41 c9 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc28678: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc2867c: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc28680: 38 63 bb 30 addi r3,r3,-17616 <== NOT EXECUTED
ffc28684: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc28688: 48 00 26 bd bl ffc2ad44 <printf> <== NOT EXECUTED
rtems_rfs_rtems_lock (fs);
ino = rtems_rfs_rtems_get_iop_ino (iop);
rc = rtems_rfs_file_open (fs, ino, flags, &file);
ffc2868c: 80 9e 00 1c lwz r4,28(r30) <== NOT EXECUTED
ffc28690: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc28694: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc28698: 38 c1 00 08 addi r6,r1,8 <== NOT EXECUTED
ffc2869c: 4b ff c0 d9 bl ffc24774 <rtems_rfs_file_open> <== NOT EXECUTED
if (rc > 0)
ffc286a0: 7c 7d 1b 79 mr. r29,r3 <== NOT EXECUTED
ffc286a4: 41 81 ff 3c bgt+ ffc285e0 <rtems_rfs_rtems_file_open+0x5c><== NOT EXECUTED
}
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
printf("rtems-rfs: file-open: handle:%p\n", file);
iop->size = rtems_rfs_file_size (file);
ffc286a8: 81 21 00 08 lwz r9,8(r1)
ffc286ac: 80 89 00 1c lwz r4,28(r9)
ffc286b0: 80 64 00 98 lwz r3,152(r4)
ffc286b4: 38 84 00 84 addi r4,r4,132
ffc286b8: 4b ff 8e 49 bl ffc21500 <rtems_rfs_block_get_size>
rtems_rfs_rtems_set_iop_file_handle (iop, file);
ffc286bc: 80 01 00 08 lwz r0,8(r1)
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc286c0: 83 bf 00 7c lwz r29,124(r31)
}
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
printf("rtems-rfs: file-open: handle:%p\n", file);
iop->size = rtems_rfs_file_size (file);
ffc286c4: 90 7e 00 08 stw r3,8(r30)
rtems_rfs_buffers_release (fs);
ffc286c8: 7f e3 fb 78 mr r3,r31
rtems_rfs_rtems_set_iop_file_handle (iop, file);
rtems_rfs_rtems_unlock (fs);
return 0;
ffc286cc: 3b e0 00 00 li r31,0
}
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
printf("rtems-rfs: file-open: handle:%p\n", file);
iop->size = rtems_rfs_file_size (file);
ffc286d0: 90 9e 00 0c stw r4,12(r30)
rtems_rfs_rtems_set_iop_file_handle (iop, file);
ffc286d4: 90 1e 00 20 stw r0,32(r30)
ffc286d8: 4b ff a7 0d bl ffc22de4 <rtems_rfs_buffers_release>
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc286dc: 80 7d 00 00 lwz r3,0(r29)
ffc286e0: 4b fe 52 39 bl ffc0d918 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc286e4: 7c 7e 1b 79 mr. r30,r3
ffc286e8: 41 82 ff 20 beq+ ffc28608 <rtems_rfs_rtems_file_open+0x84><== ALWAYS TAKEN
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc286ec: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc286f0: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc286f4: 4b fe f2 75 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc286f8: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc286fc: 41 9e ff 0c beq+ cr7,ffc28608 <rtems_rfs_rtems_file_open+0x84><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc28700: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc28704: 4b ff 41 39 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc28708: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc2870c: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc28710: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc28714: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc28718: 48 00 26 2d bl ffc2ad44 <printf> <== NOT EXECUTED
ffc2871c: 4b ff fe ec b ffc28608 <rtems_rfs_rtems_file_open+0x84><== NOT EXECUTED
ffc27bfc <rtems_rfs_rtems_file_read>:
*/
static ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
ffc27bfc: 94 21 ff d0 stwu r1,-48(r1)
ffc27c00: 7c 08 02 a6 mflr r0
ffc27c04: 90 01 00 34 stw r0,52(r1)
ffc27c08: 93 c1 00 28 stw r30,40(r1)
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
ffc27c0c: 83 c3 00 20 lwz r30,32(r3)
*/
static ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
ffc27c10: 93 e1 00 2c stw r31,44(r1)
ffc27c14: 7c 7f 1b 78 mr r31,r3
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_READ))
printf("rtems-rfs: file-read: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
ffc27c18: 81 3e 00 1c lwz r9,28(r30)
*/
static ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
ffc27c1c: 93 81 00 20 stw r28,32(r1)
ffc27c20: 7c 9c 23 78 mr r28,r4
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
ffc27c24: 38 80 00 00 li r4,0
.fpathconf_h = rtems_filesystem_default_fpathconf,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl,
.rmnod_h = rtems_rfs_rtems_rmnod
};
ffc27c28: 81 29 00 98 lwz r9,152(r9)
*/
static ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
ffc27c2c: 93 a1 00 24 stw r29,36(r1)
ffc27c30: 7c bd 2b 78 mr r29,r5
ffc27c34: 38 a0 00 00 li r5,0
.fpathconf_h = rtems_filesystem_default_fpathconf,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl,
.rmnod_h = rtems_rfs_rtems_rmnod
};
ffc27c38: 81 29 00 7c lwz r9,124(r9)
*/
static ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
ffc27c3c: 93 61 00 1c stw r27,28(r1)
ffc27c40: 80 69 00 00 lwz r3,0(r9)
ffc27c44: 93 41 00 18 stw r26,24(r1)
ffc27c48: 4b fe 5b 45 bl ffc0d78c <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
ffc27c4c: 7c 7b 1b 79 mr. r27,r3
ffc27c50: 40 82 01 dc bne- ffc27e2c <rtems_rfs_rtems_file_read+0x230><== NEVER TAKEN
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
ffc27c54: 80 9e 00 1c lwz r4,28(r30)
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_READ))
printf("rtems-rfs: file-read: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
ffc27c58: 83 7f 00 10 lwz r27,16(r31)
ffc27c5c: 80 64 00 98 lwz r3,152(r4)
ffc27c60: 38 84 00 84 addi r4,r4,132
ffc27c64: 83 ff 00 14 lwz r31,20(r31)
ffc27c68: 4b ff 98 99 bl ffc21500 <rtems_rfs_block_get_size>
if (pos < rtems_rfs_file_size (file))
ffc27c6c: 7f 83 d8 40 cmplw cr7,r3,r27
ffc27c70: 40 9d 01 2c ble- cr7,ffc27d9c <rtems_rfs_rtems_file_read+0x1a0><== ALWAYS TAKEN
{
while (count)
ffc27c74: 2f 9d 00 00 cmpwi cr7,r29,0
ffc27c78: 3b 60 00 00 li r27,0
ffc27c7c: 40 be 00 50 bne+ cr7,ffc27ccc <rtems_rfs_rtems_file_read+0xd0><== ALWAYS TAKEN
ffc27c80: 48 00 00 d0 b ffc27d50 <rtems_rfs_rtems_file_read+0x154><== NOT EXECUTED
break;
if (size > count)
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
ffc27c84: 81 3e 00 0c lwz r9,12(r30)
ffc27c88: 7f 83 e3 78 mr r3,r28
ffc27c8c: 80 1e 00 14 lwz r0,20(r30)
ffc27c90: 7f e5 fb 78 mr r5,r31
ffc27c94: 80 89 00 24 lwz r4,36(r9)
}
if (size == 0)
break;
if (size > count)
ffc27c98: 7f bf e8 50 subf r29,r31,r29
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
data += size;
ffc27c9c: 7f 9c fa 14 add r28,r28,r31
break;
if (size > count)
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
ffc27ca0: 7c 84 02 14 add r4,r4,r0
ffc27ca4: 48 00 2c f9 bl ffc2a99c <memcpy>
data += size;
count -= size;
read += size;
rc = rtems_rfs_file_io_end (file, size, true);
ffc27ca8: 7f c3 f3 78 mr r3,r30
ffc27cac: 7f e4 fb 78 mr r4,r31
ffc27cb0: 38 a0 00 01 li r5,1
ffc27cb4: 4b ff d4 59 bl ffc2510c <rtems_rfs_file_io_end>
memcpy (data, rtems_rfs_file_data (file), size);
data += size;
count -= size;
read += size;
ffc27cb8: 7f 7f da 14 add r27,r31,r27
rc = rtems_rfs_file_io_end (file, size, true);
if (rc > 0)
ffc27cbc: 7c 7a 1b 79 mr. r26,r3
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
{
while (count)
ffc27cc0: 2f 9d 00 00 cmpwi cr7,r29,0
data += size;
count -= size;
read += size;
rc = rtems_rfs_file_io_end (file, size, true);
if (rc > 0)
ffc27cc4: 41 81 00 80 bgt- ffc27d44 <rtems_rfs_rtems_file_read+0x148><== NEVER TAKEN
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
{
while (count)
ffc27cc8: 41 9e 00 88 beq- cr7,ffc27d50 <rtems_rfs_rtems_file_read+0x154><== ALWAYS TAKEN
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
ffc27ccc: 38 81 00 08 addi r4,r1,8
ffc27cd0: 38 a0 00 01 li r5,1
ffc27cd4: 7f c3 f3 78 mr r3,r30
ffc27cd8: 4b ff d1 d9 bl ffc24eb0 <rtems_rfs_file_io_start>
if (rc > 0)
ffc27cdc: 7c 7f 1b 79 mr. r31,r3
ffc27ce0: 41 81 01 80 bgt- ffc27e60 <rtems_rfs_rtems_file_read+0x264><== NEVER TAKEN
{
read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
break;
}
if (size == 0)
ffc27ce4: 83 e1 00 08 lwz r31,8(r1)
ffc27ce8: 2f 9f 00 00 cmpwi cr7,r31,0
break;
if (size > count)
ffc27cec: 7f 1f e8 40 cmplw cr6,r31,r29
{
read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
break;
}
if (size == 0)
ffc27cf0: 41 9e 00 60 beq- cr7,ffc27d50 <rtems_rfs_rtems_file_read+0x154><== NEVER TAKEN
break;
if (size > count)
ffc27cf4: 40 b9 ff 90 ble- cr6,ffc27c84 <rtems_rfs_rtems_file_read+0x88><== ALWAYS TAKEN
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
ffc27cf8: 81 3e 00 0c lwz r9,12(r30) <== NOT EXECUTED
if (size == 0)
break;
if (size > count)
size = count;
ffc27cfc: 7f bf eb 78 mr r31,r29 <== NOT EXECUTED
memcpy (data, rtems_rfs_file_data (file), size);
ffc27d00: 80 1e 00 14 lwz r0,20(r30) <== NOT EXECUTED
ffc27d04: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc27d08: 80 89 00 24 lwz r4,36(r9) <== NOT EXECUTED
ffc27d0c: 7f e5 fb 78 mr r5,r31 <== NOT EXECUTED
if (size == 0)
break;
if (size > count)
size = count;
ffc27d10: 93 a1 00 08 stw r29,8(r1) <== NOT EXECUTED
ffc27d14: 3b a0 00 00 li r29,0 <== NOT EXECUTED
memcpy (data, rtems_rfs_file_data (file), size);
ffc27d18: 7c 84 02 14 add r4,r4,r0 <== NOT EXECUTED
ffc27d1c: 48 00 2c 81 bl ffc2a99c <memcpy> <== NOT EXECUTED
data += size;
count -= size;
read += size;
rc = rtems_rfs_file_io_end (file, size, true);
ffc27d20: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc27d24: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc27d28: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc27d2c: 4b ff d3 e1 bl ffc2510c <rtems_rfs_file_io_end> <== NOT EXECUTED
if (size > count)
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
data += size;
ffc27d30: 7f 9c fa 14 add r28,r28,r31 <== NOT EXECUTED
count -= size;
read += size;
rc = rtems_rfs_file_io_end (file, size, true);
if (rc > 0)
ffc27d34: 7c 7a 1b 79 mr. r26,r3 <== NOT EXECUTED
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
{
while (count)
ffc27d38: 2f 9d 00 00 cmpwi cr7,r29,0 <== NOT EXECUTED
memcpy (data, rtems_rfs_file_data (file), size);
data += size;
count -= size;
read += size;
ffc27d3c: 7f 7f da 14 add r27,r31,r27 <== NOT EXECUTED
rc = rtems_rfs_file_io_end (file, size, true);
if (rc > 0)
ffc27d40: 40 81 ff 88 ble+ ffc27cc8 <rtems_rfs_rtems_file_read+0xcc><== NOT EXECUTED
{
read = rtems_rfs_rtems_error ("file-read: read: io-end", rc);
ffc27d44: 48 00 1f 1d bl ffc29c60 <__errno> <== NOT EXECUTED
ffc27d48: 3b 60 ff ff li r27,-1 <== NOT EXECUTED
ffc27d4c: 93 43 00 00 stw r26,0(r3) <== NOT EXECUTED
break;
}
}
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
ffc27d50: 81 3e 00 1c lwz r9,28(r30)
ffc27d54: 80 69 00 98 lwz r3,152(r9)
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc27d58: 83 e3 00 7c lwz r31,124(r3)
rtems_rfs_buffers_release (fs);
ffc27d5c: 4b ff b0 89 bl ffc22de4 <rtems_rfs_buffers_release>
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc27d60: 80 7f 00 00 lwz r3,0(r31)
ffc27d64: 4b fe 5b b5 bl ffc0d918 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc27d68: 7c 7f 1b 79 mr. r31,r3
ffc27d6c: 40 82 00 64 bne- ffc27dd0 <rtems_rfs_rtems_file_read+0x1d4><== NEVER TAKEN
return read;
}
ffc27d70: 80 01 00 34 lwz r0,52(r1)
ffc27d74: 7f 63 db 78 mr r3,r27
ffc27d78: 83 41 00 18 lwz r26,24(r1)
ffc27d7c: 7c 08 03 a6 mtlr r0
ffc27d80: 83 61 00 1c lwz r27,28(r1)
ffc27d84: 83 81 00 20 lwz r28,32(r1)
ffc27d88: 83 a1 00 24 lwz r29,36(r1)
ffc27d8c: 83 c1 00 28 lwz r30,40(r1)
ffc27d90: 83 e1 00 2c lwz r31,44(r1)
ffc27d94: 38 21 00 30 addi r1,r1,48
ffc27d98: 4e 80 00 20 blr
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
ffc27d9c: 7f 83 d8 00 cmpw cr7,r3,r27
ffc27da0: 40 9e 00 0c bne- cr7,ffc27dac <rtems_rfs_rtems_file_read+0x1b0><== NEVER TAKEN
ffc27da4: 7f 84 f8 40 cmplw cr7,r4,r31
ffc27da8: 41 9d fe cc bgt+ cr7,ffc27c74 <rtems_rfs_rtems_file_read+0x78><== ALWAYS TAKEN
break;
}
}
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
ffc27dac: 81 3e 00 1c lwz r9,28(r30) <== NOT EXECUTED
size_t count)
{
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
rtems_rfs_pos pos;
uint8_t* data = buffer;
ssize_t read = 0;
ffc27db0: 3b 60 00 00 li r27,0 <== NOT EXECUTED
break;
}
}
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
ffc27db4: 80 69 00 98 lwz r3,152(r9) <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc27db8: 83 e3 00 7c lwz r31,124(r3) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc27dbc: 4b ff b0 29 bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc27dc0: 80 7f 00 00 lwz r3,0(r31) <== NOT EXECUTED
ffc27dc4: 4b fe 5b 55 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc27dc8: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc27dcc: 41 82 ff a4 beq+ ffc27d70 <rtems_rfs_rtems_file_read+0x174><== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc27dd0: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc27dd4: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc27dd8: 4b fe fb 91 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc27ddc: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc27de0: 41 9e ff 90 beq+ cr7,ffc27d70 <rtems_rfs_rtems_file_read+0x174><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc27de4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc27de8: 4b ff 4a 55 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc27dec: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc27df0: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc27df4: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc27df8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc27dfc: 48 00 2f 49 bl ffc2ad44 <printf> <== NOT EXECUTED
return read;
}
ffc27e00: 80 01 00 34 lwz r0,52(r1) <== NOT EXECUTED
ffc27e04: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc27e08: 83 41 00 18 lwz r26,24(r1) <== NOT EXECUTED
ffc27e0c: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc27e10: 83 61 00 1c lwz r27,28(r1) <== NOT EXECUTED
ffc27e14: 83 81 00 20 lwz r28,32(r1) <== NOT EXECUTED
ffc27e18: 83 a1 00 24 lwz r29,36(r1) <== NOT EXECUTED
ffc27e1c: 83 c1 00 28 lwz r30,40(r1) <== NOT EXECUTED
ffc27e20: 83 e1 00 2c lwz r31,44(r1) <== NOT EXECUTED
ffc27e24: 38 21 00 30 addi r1,r1,48 <== NOT EXECUTED
ffc27e28: 4e 80 00 20 blr <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc27e2c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc27e30: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc27e34: 4b fe fb 35 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc27e38: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc27e3c: 41 9e fe 18 beq+ cr7,ffc27c54 <rtems_rfs_rtems_file_read+0x58><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
ffc27e40: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc27e44: 4b ff 49 f9 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc27e48: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc27e4c: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc27e50: 38 63 bb 30 addi r3,r3,-17616 <== NOT EXECUTED
ffc27e54: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc27e58: 48 00 2e ed bl ffc2ad44 <printf> <== NOT EXECUTED
ffc27e5c: 4b ff fd f8 b ffc27c54 <rtems_rfs_rtems_file_read+0x58><== NOT EXECUTED
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
if (rc > 0)
{
read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
ffc27e60: 48 00 1e 01 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc27e64: 3b 60 ff ff li r27,-1 <== NOT EXECUTED
ffc27e68: 93 e3 00 00 stw r31,0(r3) <== NOT EXECUTED
ffc27e6c: 4b ff fe e4 b ffc27d50 <rtems_rfs_rtems_file_read+0x154><== NOT EXECUTED
ffc280f4 <rtems_rfs_rtems_file_write>:
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
ffc280f4: 94 21 ff c8 stwu r1,-56(r1)
ffc280f8: 7c 08 02 a6 mflr r0
ffc280fc: 90 01 00 3c stw r0,60(r1)
ffc28100: 93 c1 00 30 stw r30,48(r1)
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
ffc28104: 83 c3 00 20 lwz r30,32(r3)
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
ffc28108: 93 61 00 24 stw r27,36(r1)
ffc2810c: 7c 7b 1b 78 mr r27,r3
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_WRITE))
printf("rtems-rfs: file-write: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
ffc28110: 81 3e 00 1c lwz r9,28(r30)
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
ffc28114: 93 41 00 20 stw r26,32(r1)
ffc28118: 7c 9a 23 78 mr r26,r4
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
ffc2811c: 38 80 00 00 li r4,0
.fpathconf_h = rtems_filesystem_default_fpathconf,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl,
.rmnod_h = rtems_rfs_rtems_rmnod
};
ffc28120: 81 29 00 98 lwz r9,152(r9)
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
ffc28124: 93 e1 00 34 stw r31,52(r1)
ffc28128: 7c bf 2b 78 mr r31,r5
ffc2812c: 38 a0 00 00 li r5,0
.fpathconf_h = rtems_filesystem_default_fpathconf,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl,
.rmnod_h = rtems_rfs_rtems_rmnod
};
ffc28130: 81 29 00 7c lwz r9,124(r9)
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
ffc28134: 93 a1 00 2c stw r29,44(r1)
ffc28138: 80 69 00 00 lwz r3,0(r9)
ffc2813c: 93 21 00 1c stw r25,28(r1)
ffc28140: 93 81 00 28 stw r28,40(r1)
ffc28144: 4b fe 56 49 bl ffc0d78c <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
ffc28148: 7c 7d 1b 79 mr. r29,r3
ffc2814c: 40 82 01 7c bne- ffc282c8 <rtems_rfs_rtems_file_write+0x1d4><== NEVER TAKEN
* size of file we are still past the end of the file as positions number
* from 0. For a specific position we need a file that has a length of one
* more.
*/
if (pos >= rtems_rfs_file_size (file))
ffc28150: 81 3e 00 1c lwz r9,28(r30)
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_WRITE))
printf("rtems-rfs: file-write: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
ffc28154: 83 9b 00 10 lwz r28,16(r27)
ffc28158: 80 69 00 98 lwz r3,152(r9)
ffc2815c: 38 89 00 84 addi r4,r9,132
ffc28160: 83 bb 00 14 lwz r29,20(r27)
ffc28164: 4b ff 93 9d bl ffc21500 <rtems_rfs_block_get_size>
* size of file we are still past the end of the file as positions number
* from 0. For a specific position we need a file that has a length of one
* more.
*/
if (pos >= rtems_rfs_file_size (file))
ffc28168: 7f 83 e0 40 cmplw cr7,r3,r28
ffc2816c: 41 9d 00 24 bgt- cr7,ffc28190 <rtems_rfs_rtems_file_write+0x9c><== NEVER TAKEN
ffc28170: 7f 83 e0 00 cmpw cr7,r3,r28
ffc28174: 41 9e 01 28 beq- cr7,ffc2829c <rtems_rfs_rtems_file_write+0x1a8><== ALWAYS TAKEN
{
rc = rtems_rfs_file_set_size (file, pos + 1);
ffc28178: 7f c3 f3 78 mr r3,r30
ffc2817c: 30 dd 00 01 addic r6,r29,1
ffc28180: 7c bc 01 94 addze r5,r28
ffc28184: 4b ff d3 d1 bl ffc25554 <rtems_rfs_file_set_size>
if (rc)
ffc28188: 7c 79 1b 79 mr. r25,r3
ffc2818c: 40 82 01 d0 bne- ffc2835c <rtems_rfs_rtems_file_write+0x268><== NEVER TAKEN
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write extend", rc);
}
}
rtems_rfs_file_set_bpos (file, pos);
ffc28190: 81 3e 00 1c lwz r9,28(r30)
ffc28194: 7f a6 eb 78 mr r6,r29
ffc28198: 7f 85 e3 78 mr r5,r28
ffc2819c: 80 69 00 98 lwz r3,152(r9)
ffc281a0: 38 fe 00 10 addi r7,r30,16
size_t count)
{
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
rtems_rfs_pos pos;
const uint8_t* data = buffer;
ssize_t write = 0;
ffc281a4: 3b a0 00 00 li r29,0
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write extend", rc);
}
}
rtems_rfs_file_set_bpos (file, pos);
ffc281a8: 4b ff 92 11 bl ffc213b8 <rtems_rfs_block_get_bpos>
while (count)
ffc281ac: 2f 9f 00 00 cmpwi cr7,r31,0
ffc281b0: 41 9e 00 84 beq- cr7,ffc28234 <rtems_rfs_rtems_file_write+0x140>
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
ffc281b4: 38 81 00 08 addi r4,r1,8
rtems_rfs_file_set_bpos (file, pos);
while (count)
{
size_t size = count;
ffc281b8: 93 e1 00 08 stw r31,8(r1)
rc = rtems_rfs_file_io_start (file, &size, false);
ffc281bc: 38 a0 00 00 li r5,0
ffc281c0: 7f c3 f3 78 mr r3,r30
ffc281c4: 4b ff cc ed bl ffc24eb0 <rtems_rfs_file_io_start>
}
if (size > count)
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
ffc281c8: 7f 44 d3 78 mr r4,r26
while (count)
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
if (rc)
ffc281cc: 7c 7c 1b 79 mr. r28,r3
ffc281d0: 40 82 01 e8 bne- ffc283b8 <rtems_rfs_rtems_file_write+0x2c4><== NEVER TAKEN
{
write = rtems_rfs_rtems_error ("file-write: write open", rc);
break;
}
if (size > count)
ffc281d4: 80 a1 00 08 lwz r5,8(r1)
ffc281d8: 7f 85 f8 40 cmplw cr7,r5,r31
ffc281dc: 40 9d 00 0c ble- cr7,ffc281e8 <rtems_rfs_rtems_file_write+0xf4><== NEVER TAKEN
size = count;
ffc281e0: 93 e1 00 08 stw r31,8(r1)
ffc281e4: 7f e5 fb 78 mr r5,r31
memcpy (rtems_rfs_file_data (file), data, size);
ffc281e8: 81 3e 00 0c lwz r9,12(r30)
ffc281ec: 80 1e 00 14 lwz r0,20(r30)
ffc281f0: 80 69 00 24 lwz r3,36(r9)
ffc281f4: 7c 63 02 14 add r3,r3,r0
ffc281f8: 48 00 27 a5 bl ffc2a99c <memcpy>
data += size;
ffc281fc: 83 81 00 08 lwz r28,8(r1)
count -= size;
write += size;
rc = rtems_rfs_file_io_end (file, size, false);
ffc28200: 7f c3 f3 78 mr r3,r30
ffc28204: 7f 84 e3 78 mr r4,r28
ffc28208: 38 a0 00 00 li r5,0
ffc2820c: 4b ff cf 01 bl ffc2510c <rtems_rfs_file_io_end>
}
}
rtems_rfs_file_set_bpos (file, pos);
while (count)
ffc28210: 7f fc f8 50 subf r31,r28,r31
data += size;
count -= size;
write += size;
rc = rtems_rfs_file_io_end (file, size, false);
if (rc)
ffc28214: 7c 79 1b 79 mr. r25,r3
}
}
rtems_rfs_file_set_bpos (file, pos);
while (count)
ffc28218: 2f 9f 00 00 cmpwi cr7,r31,0
if (size > count)
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
data += size;
ffc2821c: 7f 5a e2 14 add r26,r26,r28
count -= size;
write += size;
ffc28220: 7f bd e2 14 add r29,r29,r28
rc = rtems_rfs_file_io_end (file, size, false);
if (rc)
ffc28224: 41 82 ff 8c beq+ ffc281b0 <rtems_rfs_rtems_file_write+0xbc><== ALWAYS TAKEN
{
write = rtems_rfs_rtems_error ("file-write: write close", rc);
ffc28228: 48 00 1a 39 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc2822c: 3b a0 ff ff li r29,-1 <== NOT EXECUTED
ffc28230: 93 23 00 00 stw r25,0(r3) <== NOT EXECUTED
break;
}
}
iop->size = rtems_rfs_file_size (file);
ffc28234: 80 9e 00 1c lwz r4,28(r30)
ffc28238: 80 64 00 98 lwz r3,152(r4)
ffc2823c: 38 84 00 84 addi r4,r4,132
ffc28240: 4b ff 92 c1 bl ffc21500 <rtems_rfs_block_get_size>
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
ffc28244: 81 3e 00 1c lwz r9,28(r30)
write = rtems_rfs_rtems_error ("file-write: write close", rc);
break;
}
}
iop->size = rtems_rfs_file_size (file);
ffc28248: 90 7b 00 08 stw r3,8(r27)
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
ffc2824c: 80 69 00 98 lwz r3,152(r9)
write = rtems_rfs_rtems_error ("file-write: write close", rc);
break;
}
}
iop->size = rtems_rfs_file_size (file);
ffc28250: 90 9b 00 0c stw r4,12(r27)
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc28254: 83 e3 00 7c lwz r31,124(r3)
rtems_rfs_buffers_release (fs);
ffc28258: 4b ff ab 8d bl ffc22de4 <rtems_rfs_buffers_release>
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc2825c: 80 7f 00 00 lwz r3,0(r31)
ffc28260: 4b fe 56 b9 bl ffc0d918 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc28264: 7c 7f 1b 79 mr. r31,r3
ffc28268: 40 82 00 94 bne- ffc282fc <rtems_rfs_rtems_file_write+0x208><== NEVER TAKEN
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return write;
}
ffc2826c: 80 01 00 3c lwz r0,60(r1)
ffc28270: 7f a3 eb 78 mr r3,r29
ffc28274: 83 21 00 1c lwz r25,28(r1)
ffc28278: 7c 08 03 a6 mtlr r0
ffc2827c: 83 41 00 20 lwz r26,32(r1)
ffc28280: 83 61 00 24 lwz r27,36(r1)
ffc28284: 83 81 00 28 lwz r28,40(r1)
ffc28288: 83 a1 00 2c lwz r29,44(r1)
ffc2828c: 83 c1 00 30 lwz r30,48(r1)
ffc28290: 83 e1 00 34 lwz r31,52(r1)
ffc28294: 38 21 00 38 addi r1,r1,56
ffc28298: 4e 80 00 20 blr
* size of file we are still past the end of the file as positions number
* from 0. For a specific position we need a file that has a length of one
* more.
*/
if (pos >= rtems_rfs_file_size (file))
ffc2829c: 7f 84 e8 40 cmplw cr7,r4,r29
ffc282a0: 40 bd fe d8 ble- cr7,ffc28178 <rtems_rfs_rtems_file_write+0x84>
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write extend", rc);
}
}
rtems_rfs_file_set_bpos (file, pos);
ffc282a4: 81 3e 00 1c lwz r9,28(r30)
ffc282a8: 7f a6 eb 78 mr r6,r29
ffc282ac: 7f 85 e3 78 mr r5,r28
ffc282b0: 80 69 00 98 lwz r3,152(r9)
ffc282b4: 38 fe 00 10 addi r7,r30,16
size_t count)
{
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
rtems_rfs_pos pos;
const uint8_t* data = buffer;
ssize_t write = 0;
ffc282b8: 3b a0 00 00 li r29,0
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write extend", rc);
}
}
rtems_rfs_file_set_bpos (file, pos);
ffc282bc: 4b ff 90 fd bl ffc213b8 <rtems_rfs_block_get_bpos>
while (count)
ffc282c0: 2f 9f 00 00 cmpwi cr7,r31,0
ffc282c4: 4b ff fe ec b ffc281b0 <rtems_rfs_rtems_file_write+0xbc>
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc282c8: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc282cc: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc282d0: 4b fe f6 99 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc282d4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc282d8: 41 9e fe 78 beq+ cr7,ffc28150 <rtems_rfs_rtems_file_write+0x5c><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
ffc282dc: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc282e0: 4b ff 45 5d bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc282e4: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc282e8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc282ec: 38 63 bb 30 addi r3,r3,-17616 <== NOT EXECUTED
ffc282f0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc282f4: 48 00 2a 51 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc282f8: 4b ff fe 58 b ffc28150 <rtems_rfs_rtems_file_write+0x5c><== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc282fc: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc28300: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc28304: 4b fe f6 65 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc28308: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc2830c: 41 9e ff 60 beq+ cr7,ffc2826c <rtems_rfs_rtems_file_write+0x178><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc28310: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc28314: 4b ff 45 29 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc28318: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc2831c: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc28320: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc28324: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc28328: 48 00 2a 1d bl ffc2ad44 <printf> <== NOT EXECUTED
iop->size = rtems_rfs_file_size (file);
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return write;
}
ffc2832c: 80 01 00 3c lwz r0,60(r1) <== NOT EXECUTED
ffc28330: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc28334: 83 21 00 1c lwz r25,28(r1) <== NOT EXECUTED
ffc28338: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc2833c: 83 41 00 20 lwz r26,32(r1) <== NOT EXECUTED
ffc28340: 83 61 00 24 lwz r27,36(r1) <== NOT EXECUTED
ffc28344: 83 81 00 28 lwz r28,40(r1) <== NOT EXECUTED
ffc28348: 83 a1 00 2c lwz r29,44(r1) <== NOT EXECUTED
ffc2834c: 83 c1 00 30 lwz r30,48(r1) <== NOT EXECUTED
ffc28350: 83 e1 00 34 lwz r31,52(r1) <== NOT EXECUTED
ffc28354: 38 21 00 38 addi r1,r1,56 <== NOT EXECUTED
ffc28358: 4e 80 00 20 blr <== NOT EXECUTED
if (pos >= rtems_rfs_file_size (file))
{
rc = rtems_rfs_file_set_size (file, pos + 1);
if (rc)
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
ffc2835c: 81 3e 00 1c lwz r9,28(r30) <== NOT EXECUTED
ffc28360: 80 69 00 98 lwz r3,152(r9) <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc28364: 83 e3 00 7c lwz r31,124(r3) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc28368: 4b ff aa 7d bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc2836c: 80 7f 00 00 lwz r3,0(r31) <== NOT EXECUTED
ffc28370: 4b fe 55 a9 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc28374: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc28378: 40 82 00 50 bne- ffc283c8 <rtems_rfs_rtems_file_write+0x2d4><== NOT EXECUTED
return rtems_rfs_rtems_error ("file-write: write extend", rc);
ffc2837c: 48 00 18 e5 bl ffc29c60 <__errno> <== NOT EXECUTED
iop->size = rtems_rfs_file_size (file);
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return write;
}
ffc28380: 80 01 00 3c lwz r0,60(r1) <== NOT EXECUTED
{
rc = rtems_rfs_file_set_size (file, pos + 1);
if (rc)
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write extend", rc);
ffc28384: 3b a0 ff ff li r29,-1 <== NOT EXECUTED
ffc28388: 93 23 00 00 stw r25,0(r3) <== NOT EXECUTED
iop->size = rtems_rfs_file_size (file);
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return write;
}
ffc2838c: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc28390: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc28394: 83 21 00 1c lwz r25,28(r1) <== NOT EXECUTED
ffc28398: 83 41 00 20 lwz r26,32(r1) <== NOT EXECUTED
ffc2839c: 83 61 00 24 lwz r27,36(r1) <== NOT EXECUTED
ffc283a0: 83 81 00 28 lwz r28,40(r1) <== NOT EXECUTED
ffc283a4: 83 a1 00 2c lwz r29,44(r1) <== NOT EXECUTED
ffc283a8: 83 c1 00 30 lwz r30,48(r1) <== NOT EXECUTED
ffc283ac: 83 e1 00 34 lwz r31,52(r1) <== NOT EXECUTED
ffc283b0: 38 21 00 38 addi r1,r1,56 <== NOT EXECUTED
ffc283b4: 4e 80 00 20 blr <== NOT EXECUTED
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
if (rc)
{
write = rtems_rfs_rtems_error ("file-write: write open", rc);
ffc283b8: 48 00 18 a9 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc283bc: 3b a0 ff ff li r29,-1 <== NOT EXECUTED
ffc283c0: 93 83 00 00 stw r28,0(r3) <== NOT EXECUTED
ffc283c4: 4b ff fe 70 b ffc28234 <rtems_rfs_rtems_file_write+0x140><== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc283c8: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc283cc: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc283d0: 4b fe f5 99 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc283d4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc283d8: 41 9e ff a4 beq+ cr7,ffc2837c <rtems_rfs_rtems_file_write+0x288><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc283dc: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc283e0: 4b ff 44 5d bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc283e4: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc283e8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc283ec: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc283f0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc283f4: 48 00 29 51 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc283f8: 4b ff ff 84 b ffc2837c <rtems_rfs_rtems_file_write+0x288><== NOT EXECUTED
ffc15848 <rtems_rfs_rtems_fstat>:
}
int
rtems_rfs_rtems_fstat (rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
ffc15848: 94 21 ff b8 stwu r1,-72(r1)
ffc1584c: 7c 08 02 a6 mflr r0
ffc15850: 7c 69 1b 78 mr r9,r3
ffc15854: 90 01 00 4c stw r0,76(r1)
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
ffc15858: 38 a0 00 00 li r5,0
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc1585c: 81 63 00 10 lwz r11,16(r3)
}
int
rtems_rfs_rtems_fstat (rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
ffc15860: 93 c1 00 40 stw r30,64(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc15864: 83 cb 00 34 lwz r30,52(r11)
}
int
rtems_rfs_rtems_fstat (rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
ffc15868: 93 e1 00 44 stw r31,68(r1)
ffc1586c: 7c 9f 23 78 mr r31,r4
ffc15870: 38 80 00 00 li r4,0
rtems_rfs_mutex_destroy (&rtems->access);
free (rtems);
return rtems_rfs_rtems_error ("shutdown: close", rc);
}
ffc15874: 81 7e 00 7c lwz r11,124(r30)
}
int
rtems_rfs_rtems_fstat (rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
ffc15878: 93 81 00 38 stw r28,56(r1)
ffc1587c: 80 6b 00 00 lwz r3,0(r11)
ffc15880: 93 a1 00 3c stw r29,60(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
ffc15884: 83 a9 00 00 lwz r29,0(r9)
ffc15888: 4b ff 7f 05 bl ffc0d78c <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
ffc1588c: 7c 7c 1b 79 mr. r28,r3
ffc15890: 40 82 02 64 bne- ffc15af4 <rtems_rfs_rtems_fstat+0x2ac> <== NEVER TAKEN
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_STAT))
printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc15894: 7f a4 eb 78 mr r4,r29
ffc15898: 7f c3 f3 78 mr r3,r30
ffc1589c: 38 a1 00 08 addi r5,r1,8
ffc158a0: 38 c0 00 01 li r6,1
ffc158a4: 4b ff e7 35 bl ffc13fd8 <rtems_rfs_inode_open>
if (rc)
ffc158a8: 7c 7d 1b 79 mr. r29,r3
ffc158ac: 40 82 02 94 bne- ffc15b40 <rtems_rfs_rtems_fstat+0x2f8> <== NEVER TAKEN
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("stat: opening inode", rc);
}
mode = rtems_rfs_inode_get_mode (&inode);
ffc158b0: 81 21 00 14 lwz r9,20(r1)
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
ffc158b4: 88 69 00 02 lbz r3,2(r9)
ffc158b8: 88 09 00 03 lbz r0,3(r9)
ffc158bc: 54 63 40 2e rlwinm r3,r3,8,0,23
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
ffc158c0: 7c 63 03 78 or r3,r3,r0
ffc158c4: 54 60 04 26 rlwinm r0,r3,0,16,19
ffc158c8: 2f 80 20 00 cmpwi cr7,r0,8192
ffc158cc: 41 9e 01 cc beq- cr7,ffc15a98 <rtems_rfs_rtems_fstat+0x250><== NEVER TAKEN
ffc158d0: 2f 80 60 00 cmpwi cr7,r0,24576
ffc158d4: 41 9e 01 c4 beq- cr7,ffc15a98 <rtems_rfs_rtems_fstat+0x250><== NEVER TAKEN
buf->st_rdev =
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
rtems_rfs_inode_get_block (&inode, 1));
}
buf->st_dev = rtems_rfs_fs_device (fs);
ffc158d8: 81 3e 00 0c lwz r9,12(r30)
buf->st_ino = rtems_rfs_inode_ino (&inode);
ffc158dc: 80 01 00 10 lwz r0,16(r1)
buf->st_rdev =
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
rtems_rfs_inode_get_block (&inode, 1));
}
buf->st_dev = rtems_rfs_fs_device (fs);
ffc158e0: 81 69 00 04 lwz r11,4(r9)
ffc158e4: 81 49 00 00 lwz r10,0(r9)
ffc158e8: 91 7f 00 04 stw r11,4(r31)
buf->st_ino = rtems_rfs_inode_ino (&inode);
ffc158ec: 90 1f 00 08 stw r0,8(r31)
buf->st_rdev =
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
rtems_rfs_inode_get_block (&inode, 1));
}
buf->st_dev = rtems_rfs_fs_device (fs);
ffc158f0: 91 5f 00 00 stw r10,0(r31)
buf->st_ino = rtems_rfs_inode_ino (&inode);
buf->st_mode = rtems_rfs_rtems_mode (mode);
ffc158f4: 48 00 20 71 bl ffc17964 <rtems_rfs_rtems_mode>
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
ffc158f8: 81 21 00 14 lwz r9,20(r1)
rtems_rfs_inode_get_block (&inode, 1));
}
buf->st_dev = rtems_rfs_fs_device (fs);
buf->st_ino = rtems_rfs_inode_ino (&inode);
buf->st_mode = rtems_rfs_rtems_mode (mode);
ffc158fc: 90 7f 00 0c stw r3,12(r31)
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
ffc15900: 88 09 00 00 lbz r0,0(r9)
ffc15904: 89 69 00 01 lbz r11,1(r9)
ffc15908: 54 00 40 2e rlwinm r0,r0,8,0,23
ffc1590c: 7c 00 5b 78 or r0,r0,r11
if (links == 0xffff)
ffc15910: 6c 0b ff ff xoris r11,r0,65535
ffc15914: 2f 8b ff ff cmpwi cr7,r11,-1
ffc15918: 41 9e 02 dc beq- cr7,ffc15bf4 <rtems_rfs_rtems_fstat+0x3ac><== NEVER TAKEN
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
ffc1591c: b0 1f 00 10 sth r0,16(r31)
/*
* Need to check is the ino is an open file. If so we take the values from
* the open file rather than the inode.
*/
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
ffc15920: 7f c3 f3 78 mr r3,r30
* @return uint16_t The user id (uid).
*/
static inline uint16_t
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;
ffc15924: 88 09 00 06 lbz r0,6(r9)
ffc15928: 89 69 00 07 lbz r11,7(r9)
ffc1592c: 54 00 40 2e rlwinm r0,r0,8,0,23
ffc15930: 80 81 00 10 lwz r4,16(r1)
ffc15934: 7c 00 5b 78 or r0,r0,r11
buf->st_dev = rtems_rfs_fs_device (fs);
buf->st_ino = rtems_rfs_inode_ino (&inode);
buf->st_mode = rtems_rfs_rtems_mode (mode);
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
buf->st_uid = rtems_rfs_inode_get_uid (&inode);
ffc15938: b0 1f 00 12 sth r0,18(r31)
* @return uint16_t The group id (gid).
*/
static inline uint16_t
rtems_rfs_inode_get_gid (rtems_rfs_inode_handle* handle)
{
return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;
ffc1593c: 88 09 00 05 lbz r0,5(r9)
ffc15940: 89 69 00 04 lbz r11,4(r9)
ffc15944: 54 00 80 1e rlwinm r0,r0,16,0,15
ffc15948: 55 69 c0 0e rlwinm r9,r11,24,0,7
ffc1594c: 7d 20 03 78 or r0,r9,r0
ffc15950: 54 00 84 3e rlwinm r0,r0,16,16,31
ffc15954: b0 1f 00 14 sth r0,20(r31)
/*
* Need to check is the ino is an open file. If so we take the values from
* the open file rather than the inode.
*/
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
ffc15958: 48 00 ff 71 bl ffc258c8 <rtems_rfs_file_get_shared>
if (shared)
ffc1595c: 7c 64 1b 79 mr. r4,r3
ffc15960: 41 82 02 9c beq- ffc15bfc <rtems_rfs_rtems_fstat+0x3b4> <== ALWAYS TAKEN
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
if (S_ISLNK (buf->st_mode))
ffc15964: 81 3f 00 0c lwz r9,12(r31) <== NOT EXECUTED
ffc15968: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc1596c: 60 00 a0 00 ori r0,r0,40960 <== NOT EXECUTED
*/
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
if (shared)
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
ffc15970: 81 44 00 8c lwz r10,140(r4) <== NOT EXECUTED
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
if (S_ISLNK (buf->st_mode))
ffc15974: 55 29 04 26 rlwinm r9,r9,0,16,19 <== NOT EXECUTED
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
if (shared)
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
ffc15978: 81 64 00 90 lwz r11,144(r4) <== NOT EXECUTED
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
if (S_ISLNK (buf->st_mode))
ffc1597c: 7f 89 00 00 cmpw cr7,r9,r0 <== NOT EXECUTED
if (shared)
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
ffc15980: 81 24 00 94 lwz r9,148(r4) <== NOT EXECUTED
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
ffc15984: 80 04 00 84 lwz r0,132(r4) <== NOT EXECUTED
*/
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
if (shared)
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
ffc15988: 91 5f 00 28 stw r10,40(r31) <== NOT EXECUTED
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
ffc1598c: 91 7f 00 30 stw r11,48(r31) <== NOT EXECUTED
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
ffc15990: 91 3f 00 38 stw r9,56(r31) <== NOT EXECUTED
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
ffc15994: 90 1f 00 44 stw r0,68(r31) <== NOT EXECUTED
if (S_ISLNK (buf->st_mode))
ffc15998: 41 9e 00 80 beq- cr7,ffc15a18 <rtems_rfs_rtems_fstat+0x1d0><== NOT EXECUTED
*/
static inline rtems_rfs_pos
rtems_rfs_file_shared_get_size (rtems_rfs_file_system* fs,
rtems_rfs_file_shared* shared)
{
return rtems_rfs_block_get_size (fs, &shared->size);
ffc1599c: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc159a0: 38 84 00 84 addi r4,r4,132 <== NOT EXECUTED
ffc159a4: 48 00 bb 5d bl ffc21500 <rtems_rfs_block_get_size> <== NOT EXECUTED
buf->st_size = rtems_rfs_file_shared_get_block_offset (shared);
else
buf->st_size = rtems_rfs_file_shared_get_size (fs, shared);
ffc159a8: 90 7f 00 20 stw r3,32(r31) <== NOT EXECUTED
ffc159ac: 90 9f 00 24 stw r4,36(r31) <== NOT EXECUTED
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
else
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
}
buf->st_blksize = rtems_rfs_fs_block_size (fs);
ffc159b0: 80 1e 00 08 lwz r0,8(r30)
rc = rtems_rfs_inode_close (fs, &inode);
ffc159b4: 7f c3 f3 78 mr r3,r30
ffc159b8: 38 81 00 08 addi r4,r1,8
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
else
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
}
buf->st_blksize = rtems_rfs_fs_block_size (fs);
ffc159bc: 90 1f 00 40 stw r0,64(r31)
rc = rtems_rfs_inode_close (fs, &inode);
ffc159c0: 4b ff e8 79 bl ffc14238 <rtems_rfs_inode_close>
if (rc > 0)
ffc159c4: 7c 7f 1b 79 mr. r31,r3
ffc159c8: 40 81 00 7c ble- ffc15a44 <rtems_rfs_rtems_fstat+0x1fc> <== ALWAYS TAKEN
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc159cc: 83 be 00 7c lwz r29,124(r30) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc159d0: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc159d4: 48 00 d4 11 bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc159d8: 80 7d 00 00 lwz r3,0(r29) <== NOT EXECUTED
ffc159dc: 4b ff 7f 3d bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc159e0: 7c 7e 1b 79 mr. r30,r3 <== NOT EXECUTED
ffc159e4: 40 82 01 a8 bne- ffc15b8c <rtems_rfs_rtems_fstat+0x344> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("stat: closing inode", rc);
ffc159e8: 48 01 42 79 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc159ec: 93 e3 00 00 stw r31,0(r3) <== NOT EXECUTED
ffc159f0: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
ffc159f4: 80 01 00 4c lwz r0,76(r1)
ffc159f8: 7f e3 fb 78 mr r3,r31
ffc159fc: 83 81 00 38 lwz r28,56(r1)
ffc15a00: 7c 08 03 a6 mtlr r0
ffc15a04: 83 a1 00 3c lwz r29,60(r1)
ffc15a08: 83 c1 00 40 lwz r30,64(r1)
ffc15a0c: 83 e1 00 44 lwz r31,68(r1)
ffc15a10: 38 21 00 48 addi r1,r1,72
ffc15a14: 4e 80 00 20 blr
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
if (S_ISLNK (buf->st_mode))
buf->st_size = rtems_rfs_file_shared_get_block_offset (shared);
ffc15a18: a0 04 00 8a lhz r0,138(r4) <== NOT EXECUTED
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
}
buf->st_blksize = rtems_rfs_fs_block_size (fs);
rc = rtems_rfs_inode_close (fs, &inode);
ffc15a1c: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc15a20: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
if (S_ISLNK (buf->st_mode))
buf->st_size = rtems_rfs_file_shared_get_block_offset (shared);
ffc15a24: 90 1f 00 24 stw r0,36(r31) <== NOT EXECUTED
ffc15a28: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc15a2c: 90 1f 00 20 stw r0,32(r31) <== NOT EXECUTED
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
else
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
}
buf->st_blksize = rtems_rfs_fs_block_size (fs);
ffc15a30: 80 1e 00 08 lwz r0,8(r30) <== NOT EXECUTED
ffc15a34: 90 1f 00 40 stw r0,64(r31) <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
ffc15a38: 4b ff e8 01 bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
ffc15a3c: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc15a40: 41 81 ff 8c bgt+ ffc159cc <rtems_rfs_rtems_fstat+0x184> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc15a44: 83 fe 00 7c lwz r31,124(r30)
rtems_rfs_buffers_release (fs);
ffc15a48: 7f c3 f3 78 mr r3,r30
ffc15a4c: 48 00 d3 99 bl ffc22de4 <rtems_rfs_buffers_release>
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc15a50: 80 7f 00 00 lwz r3,0(r31)
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("stat: closing inode", rc);
}
rtems_rfs_rtems_unlock (fs);
return 0;
ffc15a54: 3b e0 00 00 li r31,0
ffc15a58: 4b ff 7e c1 bl ffc0d918 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc15a5c: 7c 7e 1b 79 mr. r30,r3
ffc15a60: 41 82 ff 94 beq+ ffc159f4 <rtems_rfs_rtems_fstat+0x1ac> <== ALWAYS TAKEN
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc15a64: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc15a68: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc15a6c: 48 00 1e fd bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc15a70: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc15a74: 41 9e ff 80 beq+ cr7,ffc159f4 <rtems_rfs_rtems_fstat+0x1ac><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc15a78: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc15a7c: 48 00 6d c1 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc15a80: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc15a84: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc15a88: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc15a8c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc15a90: 48 01 52 b5 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc15a94: 4b ff ff 60 b ffc159f4 <rtems_rfs_rtems_fstat+0x1ac> <== NOT EXECUTED
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
ffc15a98: 88 a9 00 20 lbz r5,32(r9) <== NOT EXECUTED
ffc15a9c: 88 09 00 21 lbz r0,33(r9) <== NOT EXECUTED
ffc15aa0: 88 c9 00 1c lbz r6,28(r9) <== NOT EXECUTED
ffc15aa4: 54 a5 c0 0e rlwinm r5,r5,24,0,7 <== NOT EXECUTED
ffc15aa8: 88 89 00 1d lbz r4,29(r9) <== NOT EXECUTED
ffc15aac: 54 00 80 1e rlwinm r0,r0,16,0,15 <== NOT EXECUTED
ffc15ab0: 88 e9 00 23 lbz r7,35(r9) <== NOT EXECUTED
ffc15ab4: 54 c6 c0 0e rlwinm r6,r6,24,0,7 <== NOT EXECUTED
ffc15ab8: 89 49 00 22 lbz r10,34(r9) <== NOT EXECUTED
ffc15abc: 7c a0 03 78 or r0,r5,r0 <== NOT EXECUTED
ffc15ac0: 89 09 00 1f lbz r8,31(r9) <== NOT EXECUTED
ffc15ac4: 7c 00 3b 78 or r0,r0,r7 <== NOT EXECUTED
ffc15ac8: 89 69 00 1e lbz r11,30(r9) <== NOT EXECUTED
ffc15acc: 54 89 80 1e rlwinm r9,r4,16,0,15 <== NOT EXECUTED
ffc15ad0: 7c c9 4b 78 or r9,r6,r9 <== NOT EXECUTED
ffc15ad4: 55 4a 40 2e rlwinm r10,r10,8,0,23 <== NOT EXECUTED
ffc15ad8: 7d 29 43 78 or r9,r9,r8 <== NOT EXECUTED
ffc15adc: 55 6b 40 2e rlwinm r11,r11,8,0,23 <== NOT EXECUTED
ffc15ae0: 7c 00 53 78 or r0,r0,r10 <== NOT EXECUTED
ffc15ae4: 7d 29 5b 78 or r9,r9,r11 <== NOT EXECUTED
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
{
buf->st_rdev =
ffc15ae8: 90 1f 00 1c stw r0,28(r31) <== NOT EXECUTED
ffc15aec: 91 3f 00 18 stw r9,24(r31) <== NOT EXECUTED
ffc15af0: 4b ff fd e8 b ffc158d8 <rtems_rfs_rtems_fstat+0x90> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc15af4: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc15af8: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc15afc: 48 00 1e 6d bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc15b00: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc15b04: 41 9e fd 90 beq+ cr7,ffc15894 <rtems_rfs_rtems_fstat+0x4c><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
ffc15b08: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc15b0c: 48 00 6d 31 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc15b10: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc15b14: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc15b18: 38 63 bb 30 addi r3,r3,-17616 <== NOT EXECUTED
ffc15b1c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc15b20: 48 01 52 25 bl ffc2ad44 <printf> <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_STAT))
printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc15b24: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc15b28: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc15b2c: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
ffc15b30: 38 c0 00 01 li r6,1 <== NOT EXECUTED
ffc15b34: 4b ff e4 a5 bl ffc13fd8 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
ffc15b38: 7c 7d 1b 79 mr. r29,r3 <== NOT EXECUTED
ffc15b3c: 41 82 fd 74 beq+ ffc158b0 <rtems_rfs_rtems_fstat+0x68> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc15b40: 83 fe 00 7c lwz r31,124(r30) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc15b44: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc15b48: 48 00 d2 9d bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc15b4c: 80 7f 00 00 lwz r3,0(r31) <== NOT EXECUTED
ffc15b50: 4b ff 7d c9 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc15b54: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc15b58: 40 82 00 68 bne- ffc15bc0 <rtems_rfs_rtems_fstat+0x378> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("stat: opening inode", rc);
ffc15b5c: 48 01 41 05 bl ffc29c60 <__errno> <== NOT EXECUTED
return rtems_rfs_rtems_error ("stat: closing inode", rc);
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
ffc15b60: 80 01 00 4c lwz r0,76(r1) <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
if (rc)
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("stat: opening inode", rc);
ffc15b64: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc15b68: 93 a3 00 00 stw r29,0(r3) <== NOT EXECUTED
return rtems_rfs_rtems_error ("stat: closing inode", rc);
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
ffc15b6c: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc15b70: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc15b74: 83 81 00 38 lwz r28,56(r1) <== NOT EXECUTED
ffc15b78: 83 a1 00 3c lwz r29,60(r1) <== NOT EXECUTED
ffc15b7c: 83 c1 00 40 lwz r30,64(r1) <== NOT EXECUTED
ffc15b80: 83 e1 00 44 lwz r31,68(r1) <== NOT EXECUTED
ffc15b84: 38 21 00 48 addi r1,r1,72 <== NOT EXECUTED
ffc15b88: 4e 80 00 20 blr <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc15b8c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc15b90: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc15b94: 48 00 1d d5 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc15b98: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc15b9c: 41 9e fe 4c beq+ cr7,ffc159e8 <rtems_rfs_rtems_fstat+0x1a0><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc15ba0: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc15ba4: 48 00 6c 99 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc15ba8: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc15bac: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc15bb0: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc15bb4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc15bb8: 48 01 51 8d bl ffc2ad44 <printf> <== NOT EXECUTED
ffc15bbc: 4b ff fe 2c b ffc159e8 <rtems_rfs_rtems_fstat+0x1a0> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc15bc0: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc15bc4: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc15bc8: 48 00 1d a1 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc15bcc: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc15bd0: 41 9e ff 8c beq+ cr7,ffc15b5c <rtems_rfs_rtems_fstat+0x314><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc15bd4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc15bd8: 48 00 6c 65 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc15bdc: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc15be0: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc15be4: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc15be8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc15bec: 48 01 51 59 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc15bf0: 4b ff ff 6c b ffc15b5c <rtems_rfs_rtems_fstat+0x314> <== NOT EXECUTED
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
if (links == 0xffff)
links = 0;
ffc15bf4: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc15bf8: 4b ff fd 24 b ffc1591c <rtems_rfs_rtems_fstat+0xd4> <== NOT EXECUTED
else
buf->st_size = rtems_rfs_file_shared_get_size (fs, shared);
}
else
{
buf->st_atime = rtems_rfs_inode_get_atime (&inode);
ffc15bfc: 81 21 00 14 lwz r9,20(r1)
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
if (S_ISLNK (buf->st_mode))
ffc15c00: 81 5f 00 0c lwz r10,12(r31)
* @return rtems_rfs_time The atime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_atime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->atime);
ffc15c04: 88 e9 00 10 lbz r7,16(r9)
ffc15c08: 88 09 00 11 lbz r0,17(r9)
ffc15c0c: 55 4a 04 26 rlwinm r10,r10,0,16,19
ffc15c10: 89 09 00 13 lbz r8,19(r9)
ffc15c14: 54 e7 c0 0e rlwinm r7,r7,24,0,7
ffc15c18: 89 69 00 12 lbz r11,18(r9)
ffc15c1c: 54 00 80 1e rlwinm r0,r0,16,0,15
ffc15c20: 7c e0 03 78 or r0,r7,r0
ffc15c24: 7c 00 43 78 or r0,r0,r8
ffc15c28: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc15c2c: 7c 00 5b 78 or r0,r0,r11
else
buf->st_size = rtems_rfs_file_shared_get_size (fs, shared);
}
else
{
buf->st_atime = rtems_rfs_inode_get_atime (&inode);
ffc15c30: 90 1f 00 28 stw r0,40(r31)
* @return rtems_rfs_time The mtime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_mtime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->mtime);
ffc15c34: 88 e9 00 14 lbz r7,20(r9)
ffc15c38: 88 09 00 15 lbz r0,21(r9)
ffc15c3c: 89 09 00 17 lbz r8,23(r9)
ffc15c40: 54 e7 c0 0e rlwinm r7,r7,24,0,7
ffc15c44: 89 69 00 16 lbz r11,22(r9)
ffc15c48: 54 00 80 1e rlwinm r0,r0,16,0,15
ffc15c4c: 7c e0 03 78 or r0,r7,r0
ffc15c50: 7c 00 43 78 or r0,r0,r8
ffc15c54: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc15c58: 7c 00 5b 78 or r0,r0,r11
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
ffc15c5c: 90 1f 00 30 stw r0,48(r31)
* @return rtems_rfs_time The ctime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_ctime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->ctime);
ffc15c60: 88 e9 00 18 lbz r7,24(r9)
ffc15c64: 88 09 00 19 lbz r0,25(r9)
ffc15c68: 89 09 00 1b lbz r8,27(r9)
ffc15c6c: 54 e7 c0 0e rlwinm r7,r7,24,0,7
ffc15c70: 89 69 00 1a lbz r11,26(r9)
ffc15c74: 54 00 80 1e rlwinm r0,r0,16,0,15
ffc15c78: 7c e0 03 78 or r0,r7,r0
ffc15c7c: 7c 00 43 78 or r0,r0,r8
ffc15c80: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc15c84: 7c 00 5b 78 or r0,r0,r11
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
ffc15c88: 90 1f 00 38 stw r0,56(r31)
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
if (S_ISLNK (buf->st_mode))
ffc15c8c: 39 60 00 00 li r11,0
ffc15c90: 61 6b a0 00 ori r11,r11,40960
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
ffc15c94: 89 09 00 0c lbz r8,12(r9)
ffc15c98: 7f 8a 58 00 cmpw cr7,r10,r11
ffc15c9c: 88 09 00 0d lbz r0,13(r9)
ffc15ca0: 89 49 00 0f lbz r10,15(r9)
ffc15ca4: 55 08 c0 0e rlwinm r8,r8,24,0,7
ffc15ca8: 89 69 00 0e lbz r11,14(r9)
ffc15cac: 54 00 80 1e rlwinm r0,r0,16,0,15
ffc15cb0: 7d 00 03 78 or r0,r8,r0
ffc15cb4: 7c 00 53 78 or r0,r0,r10
ffc15cb8: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc15cbc: 7c 00 5b 78 or r0,r0,r11
else
{
buf->st_atime = rtems_rfs_inode_get_atime (&inode);
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
ffc15cc0: 90 1f 00 44 stw r0,68(r31)
if (S_ISLNK (buf->st_mode))
ffc15cc4: 40 9e 00 20 bne- cr7,ffc15ce4 <rtems_rfs_rtems_fstat+0x49c>
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
ffc15cc8: 88 09 00 0a lbz r0,10(r9)
ffc15ccc: 89 29 00 0b lbz r9,11(r9)
ffc15cd0: 54 00 40 2e rlwinm r0,r0,8,0,23
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
ffc15cd4: 90 9f 00 20 stw r4,32(r31)
ffc15cd8: 7c 00 4b 78 or r0,r0,r9
ffc15cdc: 90 1f 00 24 stw r0,36(r31)
ffc15ce0: 4b ff fc d0 b ffc159b0 <rtems_rfs_rtems_fstat+0x168>
else
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
ffc15ce4: 7f c3 f3 78 mr r3,r30
ffc15ce8: 38 81 00 08 addi r4,r1,8
ffc15cec: 4b ff ed 39 bl ffc14a24 <rtems_rfs_inode_get_size>
ffc15cf0: 90 7f 00 20 stw r3,32(r31)
ffc15cf4: 90 9f 00 24 stw r4,36(r31)
ffc15cf8: 4b ff fc b8 b ffc159b0 <rtems_rfs_rtems_fstat+0x168>
ffc15f34 <rtems_rfs_rtems_initialise>:
*/
int
rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
const void* data)
{
ffc15f34: 94 21 ff d8 stwu r1,-40(r1)
ffc15f38: 7c 08 02 a6 mflr r0
ffc15f3c: 93 c1 00 20 stw r30,32(r1)
ffc15f40: 7c 7e 1b 78 mr r30,r3
rtems_rfs_rtems_private* rtems;
rtems_rfs_file_system* fs;
int rc;
rtems = malloc (sizeof (rtems_rfs_rtems_private));
ffc15f44: 38 60 00 04 li r3,4
*/
int
rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
const void* data)
{
ffc15f48: 93 e1 00 24 stw r31,36(r1)
ffc15f4c: 90 01 00 2c stw r0,44(r1)
ffc15f50: 93 a1 00 1c stw r29,28(r1)
rtems_rfs_rtems_private* rtems;
rtems_rfs_file_system* fs;
int rc;
rtems = malloc (sizeof (rtems_rfs_rtems_private));
ffc15f54: 4b ff 2e 99 bl ffc08dec <malloc>
if (!rtems)
ffc15f58: 7c 7f 1b 79 mr. r31,r3
ffc15f5c: 41 82 01 6c beq- ffc160c8 <rtems_rfs_rtems_initialise+0x194><== NEVER TAKEN
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
memset (rtems, 0, sizeof (rtems_rfs_rtems_private));
ffc15f60: 38 00 00 00 li r0,0
ffc15f64: 90 1f 00 00 stw r0,0(r31)
rc = rtems_rfs_mutex_create (&rtems->access);
ffc15f68: 48 01 0f fd bl ffc26f64 <rtems_rfs_mutex_create>
if (rc > 0)
ffc15f6c: 7c 7d 1b 79 mr. r29,r3
ffc15f70: 40 81 00 38 ble- ffc15fa8 <rtems_rfs_rtems_initialise+0x74><== ALWAYS TAKEN
}
rc = rtems_rfs_fs_open (mt_entry->dev, rtems, 0, &fs);
if (rc)
{
free (rtems);
ffc15f74: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc15f78: 4b ff 25 69 bl ffc084e0 <free> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: open", rc);
ffc15f7c: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc15f80: 48 01 3c e1 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc15f84: 93 a3 00 00 stw r29,0(r3) <== NOT EXECUTED
mt_entry->mt_fs_root.ops = &rtems_rfs_ops;
rtems_rfs_rtems_unlock (fs);
return 0;
}
ffc15f88: 80 01 00 2c lwz r0,44(r1)
ffc15f8c: 7f e3 fb 78 mr r3,r31
ffc15f90: 83 a1 00 1c lwz r29,28(r1)
ffc15f94: 7c 08 03 a6 mtlr r0
ffc15f98: 83 c1 00 20 lwz r30,32(r1)
ffc15f9c: 83 e1 00 24 lwz r31,36(r1)
ffc15fa0: 38 21 00 28 addi r1,r1,40
ffc15fa4: 4e 80 00 20 blr
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
ffc15fa8: 80 7f 00 00 lwz r3,0(r31)
ffc15fac: 38 80 00 00 li r4,0
ffc15fb0: 38 a0 00 00 li r5,0
ffc15fb4: 4b ff 77 d9 bl ffc0d78c <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
ffc15fb8: 7c 7d 1b 79 mr. r29,r3
ffc15fbc: 40 82 00 98 bne- ffc16054 <rtems_rfs_rtems_initialise+0x120><== NEVER TAKEN
rtems_rfs_mutex_destroy (&rtems->access);
free (rtems);
return rtems_rfs_rtems_error ("initialise: cannot lock access mutex", rc);
}
rc = rtems_rfs_fs_open (mt_entry->dev, rtems, 0, &fs);
ffc15fc0: 80 7e 00 70 lwz r3,112(r30)
ffc15fc4: 7f e4 fb 78 mr r4,r31
ffc15fc8: 38 a0 00 00 li r5,0
ffc15fcc: 38 c1 00 08 addi r6,r1,8
ffc15fd0: 48 00 f9 75 bl ffc25944 <rtems_rfs_fs_open>
if (rc)
ffc15fd4: 7c 7d 1b 79 mr. r29,r3
ffc15fd8: 40 a2 ff 9c bne- ffc15f74 <rtems_rfs_rtems_initialise+0x40><== NEVER TAKEN
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
ffc15fdc: 80 61 00 08 lwz r3,8(r1)
mt_entry->mt_fs_root.node_access = (void*) RTEMS_RFS_ROOT_INO;
ffc15fe0: 38 00 00 01 li r0,1
mt_entry->mt_fs_root.handlers = &rtems_rfs_rtems_dir_handlers;
ffc15fe4: 3d 20 ff c4 lis r9,-60
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc15fe8: 83 e3 00 7c lwz r31,124(r3)
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
mt_entry->mt_fs_root.node_access = (void*) RTEMS_RFS_ROOT_INO;
ffc15fec: 90 1e 00 1c stw r0,28(r30)
mt_entry->mt_fs_root.handlers = &rtems_rfs_rtems_dir_handlers;
ffc15ff0: 38 09 dc e8 addi r0,r9,-8984
mt_entry->mt_fs_root.ops = &rtems_rfs_ops;
ffc15ff4: 3d 20 ff c4 lis r9,-60
}
mt_entry->fs_info = fs;
mt_entry->mt_fs_root.node_access = (void*) RTEMS_RFS_ROOT_INO;
mt_entry->mt_fs_root.handlers = &rtems_rfs_rtems_dir_handlers;
ffc15ff8: 90 1e 00 24 stw r0,36(r30)
mt_entry->mt_fs_root.ops = &rtems_rfs_ops;
ffc15ffc: 38 09 ba b0 addi r0,r9,-17744
ffc16000: 90 1e 00 28 stw r0,40(r30)
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
ffc16004: 90 7e 00 34 stw r3,52(r30)
rtems_rfs_buffers_release (fs);
ffc16008: 48 00 cd dd bl ffc22de4 <rtems_rfs_buffers_release>
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc1600c: 80 7f 00 00 lwz r3,0(r31)
mt_entry->mt_fs_root.handlers = &rtems_rfs_rtems_dir_handlers;
mt_entry->mt_fs_root.ops = &rtems_rfs_ops;
rtems_rfs_rtems_unlock (fs);
return 0;
ffc16010: 3b e0 00 00 li r31,0
ffc16014: 4b ff 79 05 bl ffc0d918 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc16018: 7c 7e 1b 79 mr. r30,r3
ffc1601c: 41 82 ff 6c beq+ ffc15f88 <rtems_rfs_rtems_initialise+0x54><== ALWAYS TAKEN
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc16020: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc16024: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc16028: 48 00 19 41 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc1602c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc16030: 41 9e ff 58 beq+ cr7,ffc15f88 <rtems_rfs_rtems_initialise+0x54><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc16034: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc16038: 48 00 68 05 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc1603c: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc16040: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc16044: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc16048: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1604c: 48 01 4c f9 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc16050: 4b ff ff 38 b ffc15f88 <rtems_rfs_rtems_initialise+0x54><== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc16054: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc16058: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc1605c: 48 00 19 0d bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc16060: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc16064: 40 9e 00 44 bne- cr7,ffc160a8 <rtems_rfs_rtems_initialise+0x174><== NOT EXECUTED
}
rc = rtems_rfs_mutex_lock (&rtems->access);
if (rc > 0)
{
rtems_rfs_mutex_destroy (&rtems->access);
ffc16068: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1606c: 48 01 0f a1 bl ffc2700c <rtems_rfs_mutex_destroy> <== NOT EXECUTED
free (rtems);
ffc16070: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc16074: 4b ff 24 6d bl ffc084e0 <free> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot lock access mutex", rc);
ffc16078: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc1607c: 48 01 3b e5 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc16080: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc16084: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
mt_entry->mt_fs_root.ops = &rtems_rfs_ops;
rtems_rfs_rtems_unlock (fs);
return 0;
}
ffc16088: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1608c: 80 01 00 2c lwz r0,44(r1) <== NOT EXECUTED
ffc16090: 83 a1 00 1c lwz r29,28(r1) <== NOT EXECUTED
ffc16094: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc16098: 83 c1 00 20 lwz r30,32(r1) <== NOT EXECUTED
ffc1609c: 83 e1 00 24 lwz r31,36(r1) <== NOT EXECUTED
ffc160a0: 38 21 00 28 addi r1,r1,40 <== NOT EXECUTED
ffc160a4: 4e 80 00 20 blr <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
ffc160a8: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc160ac: 48 00 67 91 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc160b0: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc160b4: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc160b8: 38 63 bb 30 addi r3,r3,-17616 <== NOT EXECUTED
ffc160bc: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc160c0: 48 01 4c 85 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc160c4: 4b ff ff a4 b ffc16068 <rtems_rfs_rtems_initialise+0x134><== NOT EXECUTED
rtems_rfs_file_system* fs;
int rc;
rtems = malloc (sizeof (rtems_rfs_rtems_private));
if (!rtems)
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
ffc160c8: 48 01 3b 99 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc160cc: 38 00 00 0c li r0,12 <== NOT EXECUTED
ffc160d0: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc160d4: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc160d8: 4b ff fe b0 b ffc15f88 <rtems_rfs_rtems_initialise+0x54><== NOT EXECUTED
ffc14d34 <rtems_rfs_rtems_link>:
*/
static int
rtems_rfs_rtems_link (rtems_filesystem_location_info_t* to_loc,
rtems_filesystem_location_info_t* parent_loc,
const char* name)
{
ffc14d34: 94 21 ff e0 stwu r1,-32(r1)
ffc14d38: 7c 08 02 a6 mflr r0
ffc14d3c: 7c 69 1b 78 mr r9,r3
ffc14d40: 90 01 00 24 stw r0,36(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (to_loc);
ffc14d44: 81 63 00 10 lwz r11,16(r3)
*/
static int
rtems_rfs_rtems_link (rtems_filesystem_location_info_t* to_loc,
rtems_filesystem_location_info_t* parent_loc,
const char* name)
{
ffc14d48: 93 e1 00 1c stw r31,28(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (to_loc);
ffc14d4c: 83 eb 00 34 lwz r31,52(r11)
*/
static int
rtems_rfs_rtems_link (rtems_filesystem_location_info_t* to_loc,
rtems_filesystem_location_info_t* parent_loc,
const char* name)
{
ffc14d50: 93 81 00 10 stw r28,16(r1)
rtems_rfs_mutex_destroy (&rtems->access);
free (rtems);
return rtems_rfs_rtems_error ("shutdown: close", rc);
}
ffc14d54: 81 7f 00 7c lwz r11,124(r31)
*/
static int
rtems_rfs_rtems_link (rtems_filesystem_location_info_t* to_loc,
rtems_filesystem_location_info_t* parent_loc,
const char* name)
{
ffc14d58: 93 a1 00 14 stw r29,20(r1)
ffc14d5c: 7c bd 2b 78 mr r29,r5
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
ffc14d60: 38 a0 00 00 li r5,0
ffc14d64: 80 6b 00 00 lwz r3,0(r11)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (to_loc);
rtems_rfs_ino target = rtems_rfs_rtems_get_pathloc_ino (to_loc);
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
ffc14d68: 83 84 00 00 lwz r28,0(r4)
ffc14d6c: 38 80 00 00 li r4,0
*/
static int
rtems_rfs_rtems_link (rtems_filesystem_location_info_t* to_loc,
rtems_filesystem_location_info_t* parent_loc,
const char* name)
{
ffc14d70: 93 61 00 0c stw r27,12(r1)
ffc14d74: 93 c1 00 18 stw r30,24(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (to_loc);
rtems_rfs_ino target = rtems_rfs_rtems_get_pathloc_ino (to_loc);
ffc14d78: 83 c9 00 00 lwz r30,0(r9)
ffc14d7c: 4b ff 8a 11 bl ffc0d78c <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
ffc14d80: 7c 7b 1b 79 mr. r27,r3
ffc14d84: 40 82 00 d4 bne- ffc14e58 <rtems_rfs_rtems_link+0x124> <== NEVER TAKEN
printf ("rtems-rfs-rtems: link: in: parent:%" PRId32 " target:%" PRId32 "\n",
parent, target);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_link (fs, name, strlen (name), parent, target, false);
ffc14d88: 7f a3 eb 78 mr r3,r29
ffc14d8c: 48 01 6d 3d bl ffc2bac8 <strlen>
ffc14d90: 7f c7 f3 78 mr r7,r30
ffc14d94: 7c 65 1b 78 mr r5,r3
ffc14d98: 7f a4 eb 78 mr r4,r29
ffc14d9c: 7f e3 fb 78 mr r3,r31
ffc14da0: 7f 86 e3 78 mr r6,r28
ffc14da4: 39 00 00 00 li r8,0
ffc14da8: 48 01 15 61 bl ffc26308 <rtems_rfs_link>
if (rc)
ffc14dac: 7c 7e 1b 79 mr. r30,r3
ffc14db0: 41 82 00 54 beq- ffc14e04 <rtems_rfs_rtems_link+0xd0> <== ALWAYS TAKEN
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc14db4: 83 bf 00 7c lwz r29,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc14db8: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc14dbc: 48 00 e0 29 bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc14dc0: 80 7d 00 00 lwz r3,0(r29) <== NOT EXECUTED
ffc14dc4: 4b ff 8b 55 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc14dc8: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc14dcc: 40 82 00 c0 bne- ffc14e8c <rtems_rfs_rtems_link+0x158> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("link: linking", rc);
ffc14dd0: 48 01 4e 91 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc14dd4: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc14dd8: 93 c3 00 00 stw r30,0(r3) <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
ffc14ddc: 80 01 00 24 lwz r0,36(r1)
ffc14de0: 7f e3 fb 78 mr r3,r31
ffc14de4: 83 61 00 0c lwz r27,12(r1)
ffc14de8: 7c 08 03 a6 mtlr r0
ffc14dec: 83 81 00 10 lwz r28,16(r1)
ffc14df0: 83 a1 00 14 lwz r29,20(r1)
ffc14df4: 83 c1 00 18 lwz r30,24(r1)
ffc14df8: 83 e1 00 1c lwz r31,28(r1)
ffc14dfc: 38 21 00 20 addi r1,r1,32
ffc14e00: 4e 80 00 20 blr
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc14e04: 83 df 00 7c lwz r30,124(r31)
rtems_rfs_buffers_release (fs);
ffc14e08: 7f e3 fb 78 mr r3,r31
ffc14e0c: 48 00 df d9 bl ffc22de4 <rtems_rfs_buffers_release>
return rtems_rfs_rtems_error ("link: linking", rc);
}
rtems_rfs_rtems_unlock (fs);
return 0;
ffc14e10: 3b e0 00 00 li r31,0
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc14e14: 80 7e 00 00 lwz r3,0(r30)
ffc14e18: 4b ff 8b 01 bl ffc0d918 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc14e1c: 7c 7e 1b 79 mr. r30,r3
ffc14e20: 41 82 ff bc beq+ ffc14ddc <rtems_rfs_rtems_link+0xa8> <== ALWAYS TAKEN
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc14e24: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc14e28: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc14e2c: 48 00 2b 3d bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc14e30: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc14e34: 41 9e ff a8 beq+ cr7,ffc14ddc <rtems_rfs_rtems_link+0xa8><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc14e38: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc14e3c: 48 00 7a 01 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc14e40: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc14e44: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc14e48: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc14e4c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc14e50: 48 01 5e f5 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc14e54: 4b ff ff 88 b ffc14ddc <rtems_rfs_rtems_link+0xa8> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc14e58: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc14e5c: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc14e60: 48 00 2b 09 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc14e64: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc14e68: 41 9e ff 20 beq+ cr7,ffc14d88 <rtems_rfs_rtems_link+0x54><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
ffc14e6c: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc14e70: 48 00 79 cd bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc14e74: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc14e78: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc14e7c: 38 63 bb 30 addi r3,r3,-17616 <== NOT EXECUTED
ffc14e80: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc14e84: 48 01 5e c1 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc14e88: 4b ff ff 00 b ffc14d88 <rtems_rfs_rtems_link+0x54> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc14e8c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc14e90: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc14e94: 48 00 2a d5 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc14e98: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc14e9c: 41 9e ff 34 beq+ cr7,ffc14dd0 <rtems_rfs_rtems_link+0x9c><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc14ea0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc14ea4: 48 00 79 99 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc14ea8: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc14eac: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc14eb0: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc14eb4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc14eb8: 48 01 5e 8d bl ffc2ad44 <printf> <== NOT EXECUTED
ffc14ebc: 4b ff ff 14 b ffc14dd0 <rtems_rfs_rtems_link+0x9c> <== NOT EXECUTED
ffc163dc <rtems_rfs_rtems_mknod>:
static int
rtems_rfs_rtems_mknod (const char *name,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc)
{
ffc163dc: 94 21 ff 98 stwu r1,-104(r1)
ffc163e0: 7c 08 02 a6 mflr r0
ffc163e4: 90 01 00 6c stw r0,108(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc163e8: 81 27 00 10 lwz r9,16(r7)
static int
rtems_rfs_rtems_mknod (const char *name,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc)
{
ffc163ec: 93 e1 00 64 stw r31,100(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc163f0: 83 e9 00 34 lwz r31,52(r9)
static int
rtems_rfs_rtems_mknod (const char *name,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc)
{
ffc163f4: 92 e1 00 44 stw r23,68(r1)
ffc163f8: 93 01 00 48 stw r24,72(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (pathloc);
ffc163fc: 82 e7 00 00 lwz r23,0(r7)
static int
rtems_rfs_rtems_mknod (const char *name,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc)
{
ffc16400: 93 21 00 4c stw r25,76(r1)
ffc16404: 7c 79 1b 78 mr r25,r3
ffc16408: 93 41 00 50 stw r26,80(r1)
ffc1640c: 93 61 00 54 stw r27,84(r1)
ffc16410: 93 81 00 58 stw r28,88(r1)
ffc16414: 7c bc 2b 78 mr r28,r5
ffc16418: 93 a1 00 5c stw r29,92(r1)
ffc1641c: 7c dd 33 78 mr r29,r6
ffc16420: 93 c1 00 60 stw r30,96(r1)
ffc16424: 7c 9e 23 78 mr r30,r4
uid_t uid;
gid_t gid;
int rc;
#if defined(RTEMS_POSIX_API)
uid = geteuid ();
ffc16428: 48 00 68 85 bl ffc1ccac <geteuid>
ffc1642c: 7c 7a 1b 78 mr r26,r3
gid = getegid ();
ffc16430: 48 00 68 6d bl ffc1cc9c <getegid>
rtems_rfs_mutex_destroy (&rtems->access);
free (rtems);
return rtems_rfs_rtems_error ("shutdown: close", rc);
}
ffc16434: 81 3f 00 7c lwz r9,124(r31)
gid_t gid;
int rc;
#if defined(RTEMS_POSIX_API)
uid = geteuid ();
gid = getegid ();
ffc16438: 7c 7b 1b 78 mr r27,r3
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
ffc1643c: 38 80 00 00 li r4,0
ffc16440: 80 69 00 00 lwz r3,0(r9)
ffc16444: 38 a0 00 00 li r5,0
ffc16448: 4b ff 73 45 bl ffc0d78c <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
ffc1644c: 7c 78 1b 79 mr. r24,r3
ffc16450: 40 82 00 ac bne- ffc164fc <rtems_rfs_rtems_mknod+0x120> <== NEVER TAKEN
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
ffc16454: 7f 23 cb 78 mr r3,r25
ffc16458: 48 01 56 71 bl ffc2bac8 <strlen>
ffc1645c: 7c 78 1b 78 mr r24,r3
ffc16460: 7f c3 f3 78 mr r3,r30
ffc16464: 48 00 14 f9 bl ffc1795c <rtems_rfs_rtems_imode>
ffc16468: 7f 6a db 78 mr r10,r27
ffc1646c: 7c 67 1b 78 mr r7,r3
ffc16470: 38 01 00 10 addi r0,r1,16
ffc16474: 7f e3 fb 78 mr r3,r31
ffc16478: 90 01 00 08 stw r0,8(r1)
ffc1647c: 7e e4 bb 78 mr r4,r23
ffc16480: 7f 25 cb 78 mr r5,r25
ffc16484: 7f 06 c3 78 mr r6,r24
ffc16488: 39 00 00 01 li r8,1
ffc1648c: 7f 49 d3 78 mr r9,r26
ffc16490: 4b ff e1 cd bl ffc1465c <rtems_rfs_inode_create>
rtems_rfs_rtems_imode (mode),
1, uid, gid, &ino);
if (rc > 0)
ffc16494: 7c 7b 1b 79 mr. r27,r3
ffc16498: 40 81 00 cc ble- ffc16564 <rtems_rfs_rtems_mknod+0x188> <== ALWAYS TAKEN
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc1649c: 83 df 00 7c lwz r30,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc164a0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc164a4: 48 00 c9 41 bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc164a8: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc164ac: 4b ff 74 6d bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc164b0: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc164b4: 40 82 00 7c bne- ffc16530 <rtems_rfs_rtems_mknod+0x154> <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
if (rc > 0)
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("mknod: inode open", rc);
ffc164b8: 48 01 37 a9 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc164bc: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc164c0: 93 63 00 00 stw r27,0(r3) <== NOT EXECUTED
return rtems_rfs_rtems_error ("mknod: closing inode", rc);
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
ffc164c4: 80 01 00 6c lwz r0,108(r1)
ffc164c8: 7f e3 fb 78 mr r3,r31
ffc164cc: 82 e1 00 44 lwz r23,68(r1)
ffc164d0: 7c 08 03 a6 mtlr r0
ffc164d4: 83 01 00 48 lwz r24,72(r1)
ffc164d8: 83 21 00 4c lwz r25,76(r1)
ffc164dc: 83 41 00 50 lwz r26,80(r1)
ffc164e0: 83 61 00 54 lwz r27,84(r1)
ffc164e4: 83 81 00 58 lwz r28,88(r1)
ffc164e8: 83 a1 00 5c lwz r29,92(r1)
ffc164ec: 83 c1 00 60 lwz r30,96(r1)
ffc164f0: 83 e1 00 64 lwz r31,100(r1)
ffc164f4: 38 21 00 68 addi r1,r1,104
ffc164f8: 4e 80 00 20 blr
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc164fc: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc16500: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc16504: 48 00 14 65 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc16508: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1650c: 41 9e ff 48 beq+ cr7,ffc16454 <rtems_rfs_rtems_mknod+0x78><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
ffc16510: 7f 03 c3 78 mr r3,r24 <== NOT EXECUTED
ffc16514: 48 00 63 29 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc16518: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc1651c: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc16520: 38 63 bb 30 addi r3,r3,-17616 <== NOT EXECUTED
ffc16524: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc16528: 48 01 48 1d bl ffc2ad44 <printf> <== NOT EXECUTED
ffc1652c: 4b ff ff 28 b ffc16454 <rtems_rfs_rtems_mknod+0x78> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc16530: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc16534: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc16538: 48 00 14 31 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc1653c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc16540: 41 9e ff 78 beq+ cr7,ffc164b8 <rtems_rfs_rtems_mknod+0xdc><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc16544: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc16548: 48 00 62 f5 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc1654c: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc16550: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc16554: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc16558: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1655c: 48 01 47 e9 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc16560: 4b ff ff 58 b ffc164b8 <rtems_rfs_rtems_mknod+0xdc> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("mknod: inode create", rc);
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc16564: 80 81 00 10 lwz r4,16(r1)
ffc16568: 7f e3 fb 78 mr r3,r31
ffc1656c: 38 a1 00 14 addi r5,r1,20
ffc16570: 38 c0 00 01 li r6,1
ffc16574: 4b ff da 65 bl ffc13fd8 <rtems_rfs_inode_open>
if (rc > 0)
ffc16578: 7c 7b 1b 79 mr. r27,r3
ffc1657c: 41 a1 ff 20 bgt- ffc1649c <rtems_rfs_rtems_mknod+0xc0> <== NEVER TAKEN
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("mknod: inode open", rc);
}
if (S_ISDIR(mode) || S_ISREG(mode))
ffc16580: 57 de 04 26 rlwinm r30,r30,0,16,19
ffc16584: 2f 9e 40 00 cmpwi cr7,r30,16384
ffc16588: 41 9e 00 64 beq- cr7,ffc165ec <rtems_rfs_rtems_mknod+0x210>
ffc1658c: 6f c0 ff ff xoris r0,r30,65535
ffc16590: 2f 80 80 00 cmpwi cr7,r0,-32768
ffc16594: 41 9e 00 58 beq- cr7,ffc165ec <rtems_rfs_rtems_mknod+0x210><== ALWAYS TAKEN
{
}
else if (S_ISCHR (mode) || S_ISBLK (mode))
ffc16598: 2f 9e 20 00 cmpwi cr7,r30,8192 <== NOT EXECUTED
ffc1659c: 41 9e 00 0c beq- cr7,ffc165a8 <rtems_rfs_rtems_mknod+0x1cc><== NOT EXECUTED
ffc165a0: 2f 9e 60 00 cmpwi cr7,r30,24576 <== NOT EXECUTED
ffc165a4: 40 9e 01 10 bne- cr7,ffc166b4 <rtems_rfs_rtems_mknod+0x2d8><== NOT EXECUTED
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
ffc165a8: 81 21 00 20 lwz r9,32(r1) <== NOT EXECUTED
ffc165ac: 57 88 c2 3e rlwinm r8,r28,24,8,31 <== NOT EXECUTED
ffc165b0: 57 86 46 3e rlwinm r6,r28,8,24,31 <== NOT EXECUTED
ffc165b4: 57 87 84 3e rlwinm r7,r28,16,16,31 <== NOT EXECUTED
ffc165b8: 99 09 00 1e stb r8,30(r9) <== NOT EXECUTED
ffc165bc: 57 aa 46 3e rlwinm r10,r29,8,24,31 <== NOT EXECUTED
ffc165c0: 57 ab 84 3e rlwinm r11,r29,16,16,31 <== NOT EXECUTED
ffc165c4: 98 c9 00 1c stb r6,28(r9) <== NOT EXECUTED
ffc165c8: 57 a0 c2 3e rlwinm r0,r29,24,8,31 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc165cc: 39 00 00 01 li r8,1 <== NOT EXECUTED
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
ffc165d0: 98 e9 00 1d stb r7,29(r9) <== NOT EXECUTED
ffc165d4: 9b 89 00 1f stb r28,31(r9) <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc165d8: 99 01 00 24 stb r8,36(r1) <== NOT EXECUTED
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
ffc165dc: 99 49 00 20 stb r10,32(r9) <== NOT EXECUTED
ffc165e0: 99 69 00 21 stb r11,33(r9) <== NOT EXECUTED
ffc165e4: 98 09 00 22 stb r0,34(r9) <== NOT EXECUTED
ffc165e8: 9b a9 00 23 stb r29,35(r9) <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
}
rc = rtems_rfs_inode_close (fs, &inode);
ffc165ec: 7f e3 fb 78 mr r3,r31
ffc165f0: 38 81 00 14 addi r4,r1,20
ffc165f4: 4b ff dc 45 bl ffc14238 <rtems_rfs_inode_close>
if (rc > 0)
ffc165f8: 7c 7e 1b 79 mr. r30,r3
ffc165fc: 40 81 00 64 ble- ffc16660 <rtems_rfs_rtems_mknod+0x284> <== ALWAYS TAKEN
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc16600: 83 bf 00 7c lwz r29,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc16604: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc16608: 48 00 c7 dd bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc1660c: 80 7d 00 00 lwz r3,0(r29) <== NOT EXECUTED
ffc16610: 4b ff 73 09 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc16614: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc16618: 40 82 00 14 bne- ffc1662c <rtems_rfs_rtems_mknod+0x250> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("mknod: closing inode", rc);
ffc1661c: 48 01 36 45 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc16620: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc16624: 93 c3 00 00 stw r30,0(r3) <== NOT EXECUTED
ffc16628: 4b ff fe 9c b ffc164c4 <rtems_rfs_rtems_mknod+0xe8> <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc1662c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc16630: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc16634: 48 00 13 35 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc16638: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1663c: 41 9e ff e0 beq+ cr7,ffc1661c <rtems_rfs_rtems_mknod+0x240><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc16640: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc16644: 48 00 61 f9 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc16648: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc1664c: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc16650: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc16654: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc16658: 48 01 46 ed bl ffc2ad44 <printf> <== NOT EXECUTED
ffc1665c: 4b ff ff c0 b ffc1661c <rtems_rfs_rtems_mknod+0x240> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc16660: 83 df 00 7c lwz r30,124(r31)
rtems_rfs_buffers_release (fs);
ffc16664: 7f e3 fb 78 mr r3,r31
ffc16668: 48 00 c7 7d bl ffc22de4 <rtems_rfs_buffers_release>
}
rtems_rfs_rtems_unlock (fs);
return 0;
ffc1666c: 3b e0 00 00 li r31,0
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc16670: 80 7e 00 00 lwz r3,0(r30)
ffc16674: 4b ff 72 a5 bl ffc0d918 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc16678: 7c 7e 1b 79 mr. r30,r3
ffc1667c: 41 82 fe 48 beq+ ffc164c4 <rtems_rfs_rtems_mknod+0xe8> <== ALWAYS TAKEN
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc16680: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc16684: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc16688: 48 00 12 e1 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc1668c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc16690: 41 9e fe 34 beq+ cr7,ffc164c4 <rtems_rfs_rtems_mknod+0xe8><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc16694: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc16698: 48 00 61 a5 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc1669c: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc166a0: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc166a4: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc166a8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc166ac: 48 01 46 99 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc166b0: 4b ff fe 14 b ffc164c4 <rtems_rfs_rtems_mknod+0xe8> <== NOT EXECUTED
rtems_rfs_inode_set_block (&inode, 0, major);
rtems_rfs_inode_set_block (&inode, 1, minor);
}
else
{
rtems_rfs_inode_close (fs, &inode);
ffc166b4: 38 81 00 14 addi r4,r1,20 <== NOT EXECUTED
ffc166b8: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc166bc: 4b ff db 7d bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc166c0: 83 df 00 7c lwz r30,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc166c4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc166c8: 48 00 c7 1d bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc166cc: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc166d0: 4b ff 72 49 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc166d4: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc166d8: 40 82 00 18 bne- ffc166f0 <rtems_rfs_rtems_mknod+0x314> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
ffc166dc: 48 01 35 85 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc166e0: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc166e4: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc166e8: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc166ec: 4b ff fd d8 b ffc164c4 <rtems_rfs_rtems_mknod+0xe8> <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc166f0: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc166f4: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc166f8: 48 00 12 71 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc166fc: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc16700: 41 9e ff dc beq+ cr7,ffc166dc <rtems_rfs_rtems_mknod+0x300><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc16704: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc16708: 48 00 61 35 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc1670c: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc16710: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc16714: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc16718: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1671c: 48 01 46 29 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc16720: 4b ff ff bc b ffc166dc <rtems_rfs_rtems_mknod+0x300> <== NOT EXECUTED
ffc15cfc <rtems_rfs_rtems_node_type>:
* @return rtems_filesystem_node_types_t
*/
static rtems_filesystem_node_types_t
rtems_rfs_rtems_node_type (rtems_filesystem_location_info_t* pathloc)
{
ffc15cfc: 94 21 ff b8 stwu r1,-72(r1)
ffc15d00: 7c 08 02 a6 mflr r0
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
ffc15d04: 38 80 00 00 li r4,0
ffc15d08: 90 01 00 4c stw r0,76(r1)
ffc15d0c: 38 a0 00 00 li r5,0
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc15d10: 81 23 00 10 lwz r9,16(r3)
* @return rtems_filesystem_node_types_t
*/
static rtems_filesystem_node_types_t
rtems_rfs_rtems_node_type (rtems_filesystem_location_info_t* pathloc)
{
ffc15d14: 93 e1 00 44 stw r31,68(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc15d18: 83 e9 00 34 lwz r31,52(r9)
* @return rtems_filesystem_node_types_t
*/
static rtems_filesystem_node_types_t
rtems_rfs_rtems_node_type (rtems_filesystem_location_info_t* pathloc)
{
ffc15d1c: 93 c1 00 40 stw r30,64(r1)
rtems_rfs_mutex_destroy (&rtems->access);
free (rtems);
return rtems_rfs_rtems_error ("shutdown: close", rc);
}
ffc15d20: 81 3f 00 7c lwz r9,124(r31)
static rtems_filesystem_node_types_t
rtems_rfs_rtems_node_type (rtems_filesystem_location_info_t* pathloc)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
ffc15d24: 83 c3 00 00 lwz r30,0(r3)
ffc15d28: 80 69 00 00 lwz r3,0(r9)
* @return rtems_filesystem_node_types_t
*/
static rtems_filesystem_node_types_t
rtems_rfs_rtems_node_type (rtems_filesystem_location_info_t* pathloc)
{
ffc15d2c: 93 a1 00 3c stw r29,60(r1)
ffc15d30: 4b ff 7a 5d bl ffc0d78c <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
ffc15d34: 7c 7d 1b 79 mr. r29,r3
ffc15d38: 40 82 01 3c bne- ffc15e74 <rtems_rfs_rtems_node_type+0x178><== NEVER TAKEN
uint16_t mode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc15d3c: 7f c4 f3 78 mr r4,r30
ffc15d40: 7f e3 fb 78 mr r3,r31
ffc15d44: 38 a1 00 08 addi r5,r1,8
ffc15d48: 38 c0 00 01 li r6,1
ffc15d4c: 4b ff e2 8d bl ffc13fd8 <rtems_rfs_inode_open>
if (rc > 0)
ffc15d50: 7c 7e 1b 79 mr. r30,r3
ffc15d54: 40 81 00 80 ble- ffc15dd4 <rtems_rfs_rtems_node_type+0xd8><== ALWAYS TAKEN
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc15d58: 83 bf 00 7c lwz r29,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc15d5c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc15d60: 48 00 d0 85 bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc15d64: 80 7d 00 00 lwz r3,0(r29) <== NOT EXECUTED
ffc15d68: 4b ff 7b b1 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc15d6c: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc15d70: 40 82 00 30 bne- ffc15da0 <rtems_rfs_rtems_node_type+0xa4><== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("node_type: opening inode", rc);
ffc15d74: 48 01 3e ed bl ffc29c60 <__errno> <== NOT EXECUTED
ffc15d78: 93 c3 00 00 stw r30,0(r3) <== NOT EXECUTED
ffc15d7c: 3b c0 ff ff li r30,-1 <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return type;
}
ffc15d80: 80 01 00 4c lwz r0,76(r1)
ffc15d84: 7f c3 f3 78 mr r3,r30
ffc15d88: 83 a1 00 3c lwz r29,60(r1)
ffc15d8c: 7c 08 03 a6 mtlr r0
ffc15d90: 83 c1 00 40 lwz r30,64(r1)
ffc15d94: 83 e1 00 44 lwz r31,68(r1)
ffc15d98: 38 21 00 48 addi r1,r1,72
ffc15d9c: 4e 80 00 20 blr
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc15da0: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc15da4: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc15da8: 48 00 1b c1 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc15dac: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc15db0: 41 9e ff c4 beq+ cr7,ffc15d74 <rtems_rfs_rtems_node_type+0x78><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc15db4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc15db8: 48 00 6a 85 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc15dbc: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc15dc0: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc15dc4: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc15dc8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc15dcc: 48 01 4f 79 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc15dd0: 4b ff ff a4 b ffc15d74 <rtems_rfs_rtems_node_type+0x78><== NOT EXECUTED
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
ffc15dd4: 81 21 00 14 lwz r9,20(r1)
* etc's inode. Links to inodes can be considered "the real" one, yet they
* are all links.
*/
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISDIR (mode))
type = RTEMS_FILESYSTEM_DIRECTORY;
ffc15dd8: 3b c0 00 01 li r30,1
ffc15ddc: 88 09 00 02 lbz r0,2(r9)
* link is actually the normal path to a regular file, directory, device
* etc's inode. Links to inodes can be considered "the real" one, yet they
* are all links.
*/
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISDIR (mode))
ffc15de0: 54 00 44 26 rlwinm r0,r0,8,16,19
ffc15de4: 2f 80 40 00 cmpwi cr7,r0,16384
ffc15de8: 41 9e 00 30 beq- cr7,ffc15e18 <rtems_rfs_rtems_node_type+0x11c>
type = RTEMS_FILESYSTEM_DIRECTORY;
else if (RTEMS_RFS_S_ISLNK (mode))
ffc15dec: 39 20 00 00 li r9,0
ffc15df0: 61 29 a0 00 ori r9,r9,40960
ffc15df4: 7f 80 48 00 cmpw cr7,r0,r9
type = RTEMS_FILESYSTEM_SYM_LINK;
ffc15df8: 3b c0 00 04 li r30,4
* are all links.
*/
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISDIR (mode))
type = RTEMS_FILESYSTEM_DIRECTORY;
else if (RTEMS_RFS_S_ISLNK (mode))
ffc15dfc: 41 9e 00 1c beq- cr7,ffc15e18 <rtems_rfs_rtems_node_type+0x11c>
type = RTEMS_FILESYSTEM_SYM_LINK;
else if (RTEMS_RFS_S_ISBLK (mode) || RTEMS_RFS_S_ISCHR (mode))
ffc15e00: 2f 80 60 00 cmpwi cr7,r0,24576
type = RTEMS_FILESYSTEM_DEVICE;
ffc15e04: 3b c0 00 02 li r30,2
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISDIR (mode))
type = RTEMS_FILESYSTEM_DIRECTORY;
else if (RTEMS_RFS_S_ISLNK (mode))
type = RTEMS_FILESYSTEM_SYM_LINK;
else if (RTEMS_RFS_S_ISBLK (mode) || RTEMS_RFS_S_ISCHR (mode))
ffc15e08: 41 9e 00 10 beq- cr7,ffc15e18 <rtems_rfs_rtems_node_type+0x11c><== NEVER TAKEN
ffc15e0c: 2f 80 20 00 cmpwi cr7,r0,8192
type = RTEMS_FILESYSTEM_DEVICE;
else
type = RTEMS_FILESYSTEM_MEMORY_FILE;
ffc15e10: 3b c0 00 05 li r30,5
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISDIR (mode))
type = RTEMS_FILESYSTEM_DIRECTORY;
else if (RTEMS_RFS_S_ISLNK (mode))
type = RTEMS_FILESYSTEM_SYM_LINK;
else if (RTEMS_RFS_S_ISBLK (mode) || RTEMS_RFS_S_ISCHR (mode))
ffc15e14: 41 9e 01 18 beq- cr7,ffc15f2c <rtems_rfs_rtems_node_type+0x230><== NEVER TAKEN
type = RTEMS_FILESYSTEM_DEVICE;
else
type = RTEMS_FILESYSTEM_MEMORY_FILE;
rc = rtems_rfs_inode_close (fs, &inode);
ffc15e18: 7f e3 fb 78 mr r3,r31
ffc15e1c: 38 81 00 08 addi r4,r1,8
ffc15e20: 4b ff e4 19 bl ffc14238 <rtems_rfs_inode_close>
if (rc > 0)
ffc15e24: 7c 7d 1b 79 mr. r29,r3
ffc15e28: 40 81 00 b4 ble- ffc15edc <rtems_rfs_rtems_node_type+0x1e0><== ALWAYS TAKEN
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc15e2c: 83 df 00 7c lwz r30,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc15e30: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc15e34: 48 00 cf b1 bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc15e38: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc15e3c: 4b ff 7a dd bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc15e40: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc15e44: 40 82 00 64 bne- ffc15ea8 <rtems_rfs_rtems_node_type+0x1ac><== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("node_type: closing inode", rc);
ffc15e48: 48 01 3e 19 bl ffc29c60 <__errno> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return type;
}
ffc15e4c: 80 01 00 4c lwz r0,76(r1) <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("node_type: closing inode", rc);
ffc15e50: 3b c0 ff ff li r30,-1 <== NOT EXECUTED
ffc15e54: 93 a3 00 00 stw r29,0(r3) <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return type;
}
ffc15e58: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc15e5c: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc15e60: 83 a1 00 3c lwz r29,60(r1) <== NOT EXECUTED
ffc15e64: 83 c1 00 40 lwz r30,64(r1) <== NOT EXECUTED
ffc15e68: 83 e1 00 44 lwz r31,68(r1) <== NOT EXECUTED
ffc15e6c: 38 21 00 48 addi r1,r1,72 <== NOT EXECUTED
ffc15e70: 4e 80 00 20 blr <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc15e74: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc15e78: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc15e7c: 48 00 1a ed bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc15e80: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc15e84: 41 9e fe b8 beq+ cr7,ffc15d3c <rtems_rfs_rtems_node_type+0x40><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
ffc15e88: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc15e8c: 48 00 69 b1 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc15e90: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc15e94: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc15e98: 38 63 bb 30 addi r3,r3,-17616 <== NOT EXECUTED
ffc15e9c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc15ea0: 48 01 4e a5 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc15ea4: 4b ff fe 98 b ffc15d3c <rtems_rfs_rtems_node_type+0x40><== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc15ea8: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc15eac: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc15eb0: 48 00 1a b9 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc15eb4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc15eb8: 41 9e ff 90 beq+ cr7,ffc15e48 <rtems_rfs_rtems_node_type+0x14c><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc15ebc: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc15ec0: 48 00 69 7d bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc15ec4: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc15ec8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc15ecc: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc15ed0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc15ed4: 48 01 4e 71 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc15ed8: 4b ff ff 70 b ffc15e48 <rtems_rfs_rtems_node_type+0x14c><== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc15edc: 83 bf 00 7c lwz r29,124(r31)
rtems_rfs_buffers_release (fs);
ffc15ee0: 7f e3 fb 78 mr r3,r31
ffc15ee4: 48 00 cf 01 bl ffc22de4 <rtems_rfs_buffers_release>
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc15ee8: 80 7d 00 00 lwz r3,0(r29)
ffc15eec: 4b ff 7a 2d bl ffc0d918 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc15ef0: 7c 7f 1b 79 mr. r31,r3
ffc15ef4: 41 82 fe 8c beq+ ffc15d80 <rtems_rfs_rtems_node_type+0x84><== ALWAYS TAKEN
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc15ef8: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc15efc: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc15f00: 48 00 1a 69 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc15f04: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc15f08: 41 9e fe 78 beq+ cr7,ffc15d80 <rtems_rfs_rtems_node_type+0x84><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc15f0c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc15f10: 48 00 69 2d bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc15f14: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc15f18: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc15f1c: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc15f20: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc15f24: 48 01 4e 21 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc15f28: 4b ff fe 58 b ffc15d80 <rtems_rfs_rtems_node_type+0x84><== NOT EXECUTED
if (RTEMS_RFS_S_ISDIR (mode))
type = RTEMS_FILESYSTEM_DIRECTORY;
else if (RTEMS_RFS_S_ISLNK (mode))
type = RTEMS_FILESYSTEM_SYM_LINK;
else if (RTEMS_RFS_S_ISBLK (mode) || RTEMS_RFS_S_ISCHR (mode))
type = RTEMS_FILESYSTEM_DEVICE;
ffc15f2c: 3b c0 00 02 li r30,2 <== NOT EXECUTED
ffc15f30: 4b ff fe e8 b ffc15e18 <rtems_rfs_rtems_node_type+0x11c><== NOT EXECUTED
ffc15040 <rtems_rfs_rtems_readlink>:
static ssize_t
rtems_rfs_rtems_readlink (rtems_filesystem_location_info_t* pathloc,
char* buf,
size_t bufsize)
{
ffc15040: 94 21 ff d0 stwu r1,-48(r1)
ffc15044: 7c 08 02 a6 mflr r0
ffc15048: 7c 69 1b 78 mr r9,r3
ffc1504c: 90 01 00 34 stw r0,52(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc15050: 81 63 00 10 lwz r11,16(r3)
static ssize_t
rtems_rfs_rtems_readlink (rtems_filesystem_location_info_t* pathloc,
char* buf,
size_t bufsize)
{
ffc15054: 93 e1 00 2c stw r31,44(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc15058: 83 eb 00 34 lwz r31,52(r11)
static ssize_t
rtems_rfs_rtems_readlink (rtems_filesystem_location_info_t* pathloc,
char* buf,
size_t bufsize)
{
ffc1505c: 93 a1 00 24 stw r29,36(r1)
ffc15060: 7c 9d 23 78 mr r29,r4
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
ffc15064: 38 80 00 00 li r4,0
rtems_rfs_mutex_destroy (&rtems->access);
free (rtems);
return rtems_rfs_rtems_error ("shutdown: close", rc);
}
ffc15068: 81 7f 00 7c lwz r11,124(r31)
static ssize_t
rtems_rfs_rtems_readlink (rtems_filesystem_location_info_t* pathloc,
char* buf,
size_t bufsize)
{
ffc1506c: 93 c1 00 28 stw r30,40(r1)
ffc15070: 7c be 2b 78 mr r30,r5
ffc15074: 38 a0 00 00 li r5,0
ffc15078: 80 6b 00 00 lwz r3,0(r11)
ffc1507c: 93 61 00 1c stw r27,28(r1)
ffc15080: 93 81 00 20 stw r28,32(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
ffc15084: 83 89 00 00 lwz r28,0(r9)
ffc15088: 4b ff 87 05 bl ffc0d78c <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
ffc1508c: 7c 7b 1b 79 mr. r27,r3
ffc15090: 40 82 00 b4 bne- ffc15144 <rtems_rfs_rtems_readlink+0x104><== NEVER TAKEN
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_READLINK))
printf ("rtems-rfs-rtems: readlink: in: ino:%" PRId32 "\n", ino);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_symlink_read (fs, ino, buf, bufsize, &length);
ffc15094: 7f c6 f3 78 mr r6,r30
ffc15098: 7f e3 fb 78 mr r3,r31
ffc1509c: 7f 84 e3 78 mr r4,r28
ffc150a0: 7f a5 eb 78 mr r5,r29
ffc150a4: 38 e1 00 08 addi r7,r1,8
ffc150a8: 48 01 1c 81 bl ffc26d28 <rtems_rfs_symlink_read>
if (rc)
ffc150ac: 7c 7e 1b 79 mr. r30,r3
ffc150b0: 41 82 00 50 beq- ffc15100 <rtems_rfs_rtems_readlink+0xc0>
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc150b4: 83 bf 00 7c lwz r29,124(r31)
rtems_rfs_buffers_release (fs);
ffc150b8: 7f e3 fb 78 mr r3,r31
ffc150bc: 48 00 dd 29 bl ffc22de4 <rtems_rfs_buffers_release>
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc150c0: 80 7d 00 00 lwz r3,0(r29)
ffc150c4: 4b ff 88 55 bl ffc0d918 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc150c8: 7c 7f 1b 79 mr. r31,r3
ffc150cc: 40 82 00 e4 bne- ffc151b0 <rtems_rfs_rtems_readlink+0x170><== NEVER TAKEN
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("readlink: reading link", rc);
ffc150d0: 48 01 4b 91 bl ffc29c60 <__errno>
}
rtems_rfs_rtems_unlock (fs);
return (int) length;
}
ffc150d4: 80 01 00 34 lwz r0,52(r1)
rc = rtems_rfs_symlink_read (fs, ino, buf, bufsize, &length);
if (rc)
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("readlink: reading link", rc);
ffc150d8: 93 c3 00 00 stw r30,0(r3)
ffc150dc: 38 60 ff ff li r3,-1
}
rtems_rfs_rtems_unlock (fs);
return (int) length;
}
ffc150e0: 7c 08 03 a6 mtlr r0
ffc150e4: 83 61 00 1c lwz r27,28(r1)
ffc150e8: 83 81 00 20 lwz r28,32(r1)
ffc150ec: 83 a1 00 24 lwz r29,36(r1)
ffc150f0: 83 c1 00 28 lwz r30,40(r1)
ffc150f4: 83 e1 00 2c lwz r31,44(r1)
ffc150f8: 38 21 00 30 addi r1,r1,48
ffc150fc: 4e 80 00 20 blr
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc15100: 83 df 00 7c lwz r30,124(r31)
rtems_rfs_buffers_release (fs);
ffc15104: 7f e3 fb 78 mr r3,r31
ffc15108: 48 00 dc dd bl ffc22de4 <rtems_rfs_buffers_release>
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc1510c: 80 7e 00 00 lwz r3,0(r30)
ffc15110: 4b ff 88 09 bl ffc0d918 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc15114: 7c 7f 1b 79 mr. r31,r3
ffc15118: 40 82 00 60 bne- ffc15178 <rtems_rfs_rtems_readlink+0x138><== NEVER TAKEN
return rtems_rfs_rtems_error ("readlink: reading link", rc);
}
rtems_rfs_rtems_unlock (fs);
return (int) length;
ffc1511c: 80 61 00 08 lwz r3,8(r1)
}
ffc15120: 80 01 00 34 lwz r0,52(r1)
ffc15124: 83 61 00 1c lwz r27,28(r1)
ffc15128: 7c 08 03 a6 mtlr r0
ffc1512c: 83 81 00 20 lwz r28,32(r1)
ffc15130: 83 a1 00 24 lwz r29,36(r1)
ffc15134: 83 c1 00 28 lwz r30,40(r1)
ffc15138: 83 e1 00 2c lwz r31,44(r1)
ffc1513c: 38 21 00 30 addi r1,r1,48
ffc15140: 4e 80 00 20 blr
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc15144: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc15148: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc1514c: 48 00 28 1d bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc15150: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc15154: 41 9e ff 40 beq+ cr7,ffc15094 <rtems_rfs_rtems_readlink+0x54><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
ffc15158: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc1515c: 48 00 76 e1 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc15160: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc15164: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc15168: 38 63 bb 30 addi r3,r3,-17616 <== NOT EXECUTED
ffc1516c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc15170: 48 01 5b d5 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc15174: 4b ff ff 20 b ffc15094 <rtems_rfs_rtems_readlink+0x54><== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc15178: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1517c: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc15180: 48 00 27 e9 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc15184: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc15188: 41 9e ff 94 beq+ cr7,ffc1511c <rtems_rfs_rtems_readlink+0xdc><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc1518c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc15190: 48 00 76 ad bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc15194: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc15198: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc1519c: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc151a0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc151a4: 48 01 5b a1 bl ffc2ad44 <printf> <== NOT EXECUTED
return rtems_rfs_rtems_error ("readlink: reading link", rc);
}
rtems_rfs_rtems_unlock (fs);
return (int) length;
ffc151a8: 80 61 00 08 lwz r3,8(r1) <== NOT EXECUTED
ffc151ac: 4b ff ff 74 b ffc15120 <rtems_rfs_rtems_readlink+0xe0><== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc151b0: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc151b4: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc151b8: 48 00 27 b1 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc151bc: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc151c0: 41 9e ff 10 beq+ cr7,ffc150d0 <rtems_rfs_rtems_readlink+0x90><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc151c4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc151c8: 48 00 76 75 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc151cc: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc151d0: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc151d4: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc151d8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc151dc: 48 01 5b 69 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc151e0: 4b ff fe f0 b ffc150d0 <rtems_rfs_rtems_readlink+0x90><== NOT EXECUTED
ffc153a0 <rtems_rfs_rtems_rename>:
static int
rtems_rfs_rtems_rename(rtems_filesystem_location_info_t* old_parent_loc,
rtems_filesystem_location_info_t* old_loc,
rtems_filesystem_location_info_t* new_parent_loc,
const char* new_name)
{
ffc153a0: 94 21 ff d8 stwu r1,-40(r1) <== NOT EXECUTED
ffc153a4: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc153a8: 7c 89 23 78 mr r9,r4 <== NOT EXECUTED
ffc153ac: 90 01 00 2c stw r0,44(r1) <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (old_loc);
ffc153b0: 81 64 00 10 lwz r11,16(r4) <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
ffc153b4: 38 80 00 00 li r4,0 <== NOT EXECUTED
static int
rtems_rfs_rtems_rename(rtems_filesystem_location_info_t* old_parent_loc,
rtems_filesystem_location_info_t* old_loc,
rtems_filesystem_location_info_t* new_parent_loc,
const char* new_name)
{
ffc153b8: 93 e1 00 24 stw r31,36(r1) <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (old_loc);
ffc153bc: 83 eb 00 34 lwz r31,52(r11) <== NOT EXECUTED
static int
rtems_rfs_rtems_rename(rtems_filesystem_location_info_t* old_parent_loc,
rtems_filesystem_location_info_t* old_loc,
rtems_filesystem_location_info_t* new_parent_loc,
const char* new_name)
{
ffc153c0: 93 81 00 18 stw r28,24(r1) <== NOT EXECUTED
rtems_rfs_mutex_destroy (&rtems->access);
free (rtems);
return rtems_rfs_rtems_error ("shutdown: close", rc);
}
ffc153c4: 81 7f 00 7c lwz r11,124(r31) <== NOT EXECUTED
rtems_rfs_ino new_parent;
rtems_rfs_ino ino;
uint32_t doff;
int rc;
old_parent = rtems_rfs_rtems_get_pathloc_ino (old_parent_loc);
ffc153c8: 83 83 00 00 lwz r28,0(r3) <== NOT EXECUTED
ffc153cc: 80 6b 00 00 lwz r3,0(r11) <== NOT EXECUTED
static int
rtems_rfs_rtems_rename(rtems_filesystem_location_info_t* old_parent_loc,
rtems_filesystem_location_info_t* old_loc,
rtems_filesystem_location_info_t* new_parent_loc,
const char* new_name)
{
ffc153d0: 93 61 00 14 stw r27,20(r1) <== NOT EXECUTED
rtems_rfs_ino ino;
uint32_t doff;
int rc;
old_parent = rtems_rfs_rtems_get_pathloc_ino (old_parent_loc);
new_parent = rtems_rfs_rtems_get_pathloc_ino (new_parent_loc);
ffc153d4: 83 65 00 00 lwz r27,0(r5) <== NOT EXECUTED
ffc153d8: 38 a0 00 00 li r5,0 <== NOT EXECUTED
static int
rtems_rfs_rtems_rename(rtems_filesystem_location_info_t* old_parent_loc,
rtems_filesystem_location_info_t* old_loc,
rtems_filesystem_location_info_t* new_parent_loc,
const char* new_name)
{
ffc153dc: 93 21 00 0c stw r25,12(r1) <== NOT EXECUTED
ffc153e0: 93 41 00 10 stw r26,16(r1) <== NOT EXECUTED
ffc153e4: 7c da 33 78 mr r26,r6 <== NOT EXECUTED
ffc153e8: 93 a1 00 1c stw r29,28(r1) <== NOT EXECUTED
ffc153ec: 93 c1 00 20 stw r30,32(r1) <== NOT EXECUTED
old_parent = rtems_rfs_rtems_get_pathloc_ino (old_parent_loc);
new_parent = rtems_rfs_rtems_get_pathloc_ino (new_parent_loc);
ino = rtems_rfs_rtems_get_pathloc_ino (old_loc);
doff = rtems_rfs_rtems_get_pathloc_doff (old_loc);
ffc153f0: 83 a9 00 04 lwz r29,4(r9) <== NOT EXECUTED
int rc;
old_parent = rtems_rfs_rtems_get_pathloc_ino (old_parent_loc);
new_parent = rtems_rfs_rtems_get_pathloc_ino (new_parent_loc);
ino = rtems_rfs_rtems_get_pathloc_ino (old_loc);
ffc153f4: 83 c9 00 00 lwz r30,0(r9) <== NOT EXECUTED
ffc153f8: 4b ff 83 95 bl ffc0d78c <rtems_semaphore_obtain> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc153fc: 7c 79 1b 79 mr. r25,r3 <== NOT EXECUTED
ffc15400: 40 82 01 54 bne- ffc15554 <rtems_rfs_rtems_rename+0x1b4><== NOT EXECUTED
/*
* Link to the inode before unlinking so the inode is not erased when
* unlinked.
*/
rc = rtems_rfs_link (fs, new_name, strlen (new_name), new_parent, ino, true);
ffc15404: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc15408: 48 01 66 c1 bl ffc2bac8 <strlen> <== NOT EXECUTED
ffc1540c: 7f 66 db 78 mr r6,r27 <== NOT EXECUTED
ffc15410: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc15414: 7f 44 d3 78 mr r4,r26 <== NOT EXECUTED
ffc15418: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1541c: 7f c7 f3 78 mr r7,r30 <== NOT EXECUTED
ffc15420: 39 00 00 01 li r8,1 <== NOT EXECUTED
ffc15424: 48 01 0e e5 bl ffc26308 <rtems_rfs_link> <== NOT EXECUTED
if (rc)
ffc15428: 7c 7b 1b 79 mr. r27,r3 <== NOT EXECUTED
ffc1542c: 41 82 00 5c beq- ffc15488 <rtems_rfs_rtems_rename+0xe8> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc15430: 83 df 00 7c lwz r30,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc15434: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc15438: 48 00 d9 ad bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc1543c: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc15440: 4b ff 84 d9 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc15444: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc15448: 40 82 01 40 bne- ffc15588 <rtems_rfs_rtems_rename+0x1e8><== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("rename: linking", rc);
ffc1544c: 48 01 48 15 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc15450: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc15454: 93 63 00 00 stw r27,0(r3) <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
ffc15458: 80 01 00 2c lwz r0,44(r1) <== NOT EXECUTED
ffc1545c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc15460: 83 21 00 0c lwz r25,12(r1) <== NOT EXECUTED
ffc15464: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc15468: 83 41 00 10 lwz r26,16(r1) <== NOT EXECUTED
ffc1546c: 83 61 00 14 lwz r27,20(r1) <== NOT EXECUTED
ffc15470: 83 81 00 18 lwz r28,24(r1) <== NOT EXECUTED
ffc15474: 83 a1 00 1c lwz r29,28(r1) <== NOT EXECUTED
ffc15478: 83 c1 00 20 lwz r30,32(r1) <== NOT EXECUTED
ffc1547c: 83 e1 00 24 lwz r31,36(r1) <== NOT EXECUTED
ffc15480: 38 21 00 28 addi r1,r1,40 <== NOT EXECUTED
ffc15484: 4e 80 00 20 blr <== NOT EXECUTED
/*
* Unlink all inodes even directories with the dir option as false because a
* directory may not be empty.
*/
rc = rtems_rfs_unlink (fs, old_parent, ino, doff,
ffc15488: 7f c5 f3 78 mr r5,r30 <== NOT EXECUTED
ffc1548c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc15490: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc15494: 7f a6 eb 78 mr r6,r29 <== NOT EXECUTED
ffc15498: 38 e0 00 02 li r7,2 <== NOT EXECUTED
ffc1549c: 48 01 10 d5 bl ffc26570 <rtems_rfs_unlink> <== NOT EXECUTED
rtems_rfs_unlink_dir_allowed);
if (rc)
ffc154a0: 7c 7e 1b 79 mr. r30,r3 <== NOT EXECUTED
ffc154a4: 41 82 00 5c beq- ffc15500 <rtems_rfs_rtems_rename+0x160><== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc154a8: 83 bf 00 7c lwz r29,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc154ac: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc154b0: 48 00 d9 35 bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc154b4: 80 7d 00 00 lwz r3,0(r29) <== NOT EXECUTED
ffc154b8: 4b ff 84 61 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc154bc: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc154c0: 40 82 00 fc bne- ffc155bc <rtems_rfs_rtems_rename+0x21c><== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("rename: unlinking", rc);
ffc154c4: 48 01 47 9d bl ffc29c60 <__errno> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
ffc154c8: 80 01 00 2c lwz r0,44(r1) <== NOT EXECUTED
rc = rtems_rfs_unlink (fs, old_parent, ino, doff,
rtems_rfs_unlink_dir_allowed);
if (rc)
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("rename: unlinking", rc);
ffc154cc: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc154d0: 93 c3 00 00 stw r30,0(r3) <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
ffc154d4: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc154d8: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc154dc: 83 21 00 0c lwz r25,12(r1) <== NOT EXECUTED
ffc154e0: 83 41 00 10 lwz r26,16(r1) <== NOT EXECUTED
ffc154e4: 83 61 00 14 lwz r27,20(r1) <== NOT EXECUTED
ffc154e8: 83 81 00 18 lwz r28,24(r1) <== NOT EXECUTED
ffc154ec: 83 a1 00 1c lwz r29,28(r1) <== NOT EXECUTED
ffc154f0: 83 c1 00 20 lwz r30,32(r1) <== NOT EXECUTED
ffc154f4: 83 e1 00 24 lwz r31,36(r1) <== NOT EXECUTED
ffc154f8: 38 21 00 28 addi r1,r1,40 <== NOT EXECUTED
ffc154fc: 4e 80 00 20 blr <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc15500: 83 df 00 7c lwz r30,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc15504: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc15508: 48 00 d8 dd bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
return rtems_rfs_rtems_error ("rename: unlinking", rc);
}
rtems_rfs_rtems_unlock (fs);
return 0;
ffc1550c: 3b e0 00 00 li r31,0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc15510: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc15514: 4b ff 84 05 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc15518: 7c 7e 1b 79 mr. r30,r3 <== NOT EXECUTED
ffc1551c: 41 82 ff 3c beq+ ffc15458 <rtems_rfs_rtems_rename+0xb8> <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc15520: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc15524: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc15528: 48 00 24 41 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc1552c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc15530: 41 9e ff 28 beq+ cr7,ffc15458 <rtems_rfs_rtems_rename+0xb8><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc15534: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc15538: 48 00 73 05 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc1553c: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc15540: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc15544: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc15548: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1554c: 48 01 57 f9 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc15550: 4b ff ff 08 b ffc15458 <rtems_rfs_rtems_rename+0xb8> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc15554: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc15558: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc1555c: 48 00 24 0d bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc15560: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc15564: 41 9e fe a0 beq+ cr7,ffc15404 <rtems_rfs_rtems_rename+0x64><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
ffc15568: 7f 23 cb 78 mr r3,r25 <== NOT EXECUTED
ffc1556c: 48 00 72 d1 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc15570: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc15574: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc15578: 38 63 bb 30 addi r3,r3,-17616 <== NOT EXECUTED
ffc1557c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc15580: 48 01 57 c5 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc15584: 4b ff fe 80 b ffc15404 <rtems_rfs_rtems_rename+0x64> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc15588: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1558c: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc15590: 48 00 23 d9 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc15594: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc15598: 41 9e fe b4 beq+ cr7,ffc1544c <rtems_rfs_rtems_rename+0xac><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc1559c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc155a0: 48 00 72 9d bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc155a4: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc155a8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc155ac: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc155b0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc155b4: 48 01 57 91 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc155b8: 4b ff fe 94 b ffc1544c <rtems_rfs_rtems_rename+0xac> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc155bc: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc155c0: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc155c4: 48 00 23 a5 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc155c8: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc155cc: 41 9e fe f8 beq+ cr7,ffc154c4 <rtems_rfs_rtems_rename+0x124><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc155d0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc155d4: 48 00 72 69 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc155d8: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc155dc: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc155e0: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc155e4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc155e8: 48 01 57 5d bl ffc2ad44 <printf> <== NOT EXECUTED
ffc155ec: 4b ff fe d8 b ffc154c4 <rtems_rfs_rtems_rename+0x124><== NOT EXECUTED
ffc14ec0 <rtems_rfs_rtems_rmnod>:
* @return int
*/
int
rtems_rfs_rtems_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
ffc14ec0: 94 21 ff e0 stwu r1,-32(r1) <== NOT EXECUTED
ffc14ec4: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc14ec8: 7c 89 23 78 mr r9,r4 <== NOT EXECUTED
ffc14ecc: 90 01 00 24 stw r0,36(r1) <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
ffc14ed0: 38 a0 00 00 li r5,0 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc14ed4: 81 64 00 10 lwz r11,16(r4) <== NOT EXECUTED
ffc14ed8: 38 80 00 00 li r4,0 <== NOT EXECUTED
* @return int
*/
int
rtems_rfs_rtems_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
ffc14edc: 93 e1 00 1c stw r31,28(r1) <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc14ee0: 83 eb 00 34 lwz r31,52(r11) <== NOT EXECUTED
* @return int
*/
int
rtems_rfs_rtems_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
ffc14ee4: 93 81 00 10 stw r28,16(r1) <== NOT EXECUTED
rtems_rfs_mutex_destroy (&rtems->access);
free (rtems);
return rtems_rfs_rtems_error ("shutdown: close", rc);
}
ffc14ee8: 81 7f 00 7c lwz r11,124(r31) <== NOT EXECUTED
int
rtems_rfs_rtems_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_pathloc);
ffc14eec: 83 83 00 00 lwz r28,0(r3) <== NOT EXECUTED
ffc14ef0: 80 6b 00 00 lwz r3,0(r11) <== NOT EXECUTED
* @return int
*/
int
rtems_rfs_rtems_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
ffc14ef4: 93 61 00 0c stw r27,12(r1) <== NOT EXECUTED
ffc14ef8: 93 a1 00 14 stw r29,20(r1) <== NOT EXECUTED
ffc14efc: 93 c1 00 18 stw r30,24(r1) <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_pathloc);
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
ffc14f00: 83 a9 00 00 lwz r29,0(r9) <== NOT EXECUTED
uint32_t doff = rtems_rfs_rtems_get_pathloc_doff (pathloc);
ffc14f04: 83 c9 00 04 lwz r30,4(r9) <== NOT EXECUTED
ffc14f08: 4b ff 88 85 bl ffc0d78c <rtems_semaphore_obtain> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc14f0c: 7c 7b 1b 79 mr. r27,r3 <== NOT EXECUTED
ffc14f10: 40 82 00 c8 bne- ffc14fd8 <rtems_rfs_rtems_rmnod+0x118> <== NOT EXECUTED
printf ("rtems-rfs: rmnod: parent:%" PRId32 " doff:%" PRIu32 ", ino:%" PRId32 "\n",
parent, doff, ino);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_denied);
ffc14f14: 7f c6 f3 78 mr r6,r30 <== NOT EXECUTED
ffc14f18: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc14f1c: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc14f20: 7f a5 eb 78 mr r5,r29 <== NOT EXECUTED
ffc14f24: 38 e0 00 00 li r7,0 <== NOT EXECUTED
ffc14f28: 48 01 16 49 bl ffc26570 <rtems_rfs_unlink> <== NOT EXECUTED
if (rc)
ffc14f2c: 7c 7e 1b 79 mr. r30,r3 <== NOT EXECUTED
ffc14f30: 41 82 00 54 beq- ffc14f84 <rtems_rfs_rtems_rmnod+0xc4> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc14f34: 83 bf 00 7c lwz r29,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc14f38: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc14f3c: 48 00 de a9 bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc14f40: 80 7d 00 00 lwz r3,0(r29) <== NOT EXECUTED
ffc14f44: 4b ff 89 d5 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc14f48: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc14f4c: 40 82 00 c0 bne- ffc1500c <rtems_rfs_rtems_rmnod+0x14c> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("rmnod: unlinking", rc);
ffc14f50: 48 01 4d 11 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc14f54: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc14f58: 93 c3 00 00 stw r30,0(r3) <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
ffc14f5c: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
ffc14f60: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc14f64: 83 61 00 0c lwz r27,12(r1) <== NOT EXECUTED
ffc14f68: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc14f6c: 83 81 00 10 lwz r28,16(r1) <== NOT EXECUTED
ffc14f70: 83 a1 00 14 lwz r29,20(r1) <== NOT EXECUTED
ffc14f74: 83 c1 00 18 lwz r30,24(r1) <== NOT EXECUTED
ffc14f78: 83 e1 00 1c lwz r31,28(r1) <== NOT EXECUTED
ffc14f7c: 38 21 00 20 addi r1,r1,32 <== NOT EXECUTED
ffc14f80: 4e 80 00 20 blr <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc14f84: 83 df 00 7c lwz r30,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc14f88: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc14f8c: 48 00 de 59 bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("rmnod: unlinking", rc);
}
rtems_rfs_rtems_unlock (fs);
return 0;
ffc14f90: 3b e0 00 00 li r31,0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc14f94: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc14f98: 4b ff 89 81 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc14f9c: 7c 7e 1b 79 mr. r30,r3 <== NOT EXECUTED
ffc14fa0: 41 82 ff bc beq+ ffc14f5c <rtems_rfs_rtems_rmnod+0x9c> <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc14fa4: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc14fa8: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc14fac: 48 00 29 bd bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc14fb0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc14fb4: 41 9e ff a8 beq+ cr7,ffc14f5c <rtems_rfs_rtems_rmnod+0x9c><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc14fb8: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc14fbc: 48 00 78 81 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc14fc0: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc14fc4: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc14fc8: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc14fcc: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc14fd0: 48 01 5d 75 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc14fd4: 4b ff ff 88 b ffc14f5c <rtems_rfs_rtems_rmnod+0x9c> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc14fd8: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc14fdc: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc14fe0: 48 00 29 89 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc14fe4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc14fe8: 41 9e ff 2c beq+ cr7,ffc14f14 <rtems_rfs_rtems_rmnod+0x54><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
ffc14fec: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc14ff0: 48 00 78 4d bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc14ff4: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc14ff8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc14ffc: 38 63 bb 30 addi r3,r3,-17616 <== NOT EXECUTED
ffc15000: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc15004: 48 01 5d 41 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc15008: 4b ff ff 0c b ffc14f14 <rtems_rfs_rtems_rmnod+0x54> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc1500c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc15010: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc15014: 48 00 29 55 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc15018: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1501c: 41 9e ff 34 beq+ cr7,ffc14f50 <rtems_rfs_rtems_rmnod+0x90><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc15020: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc15024: 48 00 78 19 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc15028: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc1502c: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc15030: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc15034: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc15038: 48 01 5d 0d bl ffc2ad44 <printf> <== NOT EXECUTED
ffc1503c: 4b ff ff 14 b ffc14f50 <rtems_rfs_rtems_rmnod+0x90> <== NOT EXECUTED
ffc1785c <rtems_rfs_rtems_set_handlers>:
*/
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
ffc1785c: 94 21 ff f8 stwu r1,-8(r1)
ffc17860: 7c 08 02 a6 mflr r0
ffc17864: 90 01 00 0c stw r0,12(r1)
{
/*
* Mapping matches RTEMS so no need to change.
*/
return imode;
}
ffc17868: 81 24 00 0c lwz r9,12(r4)
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
ffc1786c: 88 89 00 02 lbz r4,2(r9)
ffc17870: 88 09 00 03 lbz r0,3(r9)
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
ffc17874: 39 20 00 00 li r9,0
ffc17878: 54 84 40 2e rlwinm r4,r4,8,0,23
ffc1787c: 91 23 00 08 stw r9,8(r3)
ffc17880: 7c 84 03 78 or r4,r4,r0
if (RTEMS_RFS_S_ISDIR (mode))
ffc17884: 54 80 04 26 rlwinm r0,r4,0,16,19
ffc17888: 2f 80 40 00 cmpwi cr7,r0,16384
ffc1788c: 41 9e 00 90 beq- cr7,ffc1791c <rtems_rfs_rtems_set_handlers+0xc0>
loc->handlers = rtems_rfs_rtems_handlers (dir);
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
ffc17890: 2f 80 20 00 cmpwi cr7,r0,8192
ffc17894: 41 9e 00 48 beq- cr7,ffc178dc <rtems_rfs_rtems_set_handlers+0x80><== NEVER TAKEN
ffc17898: 2f 80 60 00 cmpwi cr7,r0,24576
ffc1789c: 41 9e 00 40 beq- cr7,ffc178dc <rtems_rfs_rtems_set_handlers+0x80><== NEVER TAKEN
loc->handlers = rtems_rfs_rtems_handlers (device);
else if (RTEMS_RFS_S_ISLNK (mode))
ffc178a0: 6c 09 ff ff xoris r9,r0,65535
ffc178a4: 2f 89 a0 00 cmpwi cr7,r9,-24576
ffc178a8: 41 9e 00 54 beq- cr7,ffc178fc <rtems_rfs_rtems_set_handlers+0xa0>
loc->handlers = rtems_rfs_rtems_handlers (link);
else if (RTEMS_RFS_S_ISREG (mode))
ffc178ac: 6c 09 ff ff xoris r9,r0,65535
ffc178b0: 2f 89 80 00 cmpwi cr7,r9,-32768
ffc178b4: 41 9e 00 88 beq- cr7,ffc1793c <rtems_rfs_rtems_set_handlers+0xe0><== ALWAYS TAKEN
loc->handlers = rtems_rfs_rtems_handlers (file);
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
ffc178b8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc178bc: 38 63 bb 80 addi r3,r3,-17536 <== NOT EXECUTED
ffc178c0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc178c4: 48 01 34 81 bl ffc2ad44 <printf> <== NOT EXECUTED
return false;
}
return true;
}
ffc178c8: 80 01 00 0c lwz r0,12(r1) <== NOT EXECUTED
else if (RTEMS_RFS_S_ISREG (mode))
loc->handlers = rtems_rfs_rtems_handlers (file);
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
ffc178cc: 38 60 00 00 li r3,0 <== NOT EXECUTED
}
return true;
}
ffc178d0: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc178d4: 38 21 00 08 addi r1,r1,8 <== NOT EXECUTED
ffc178d8: 4e 80 00 20 blr <== NOT EXECUTED
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
if (RTEMS_RFS_S_ISDIR (mode))
loc->handlers = rtems_rfs_rtems_handlers (dir);
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
loc->handlers = rtems_rfs_rtems_handlers (device);
ffc178dc: 3d 20 ff c4 lis r9,-60 <== NOT EXECUTED
ffc178e0: 38 09 dc b0 addi r0,r9,-9040 <== NOT EXECUTED
ffc178e4: 90 03 00 08 stw r0,8(r3) <== NOT EXECUTED
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
ffc178e8: 38 60 00 01 li r3,1 <== NOT EXECUTED
}
ffc178ec: 80 01 00 0c lwz r0,12(r1) <== NOT EXECUTED
ffc178f0: 38 21 00 08 addi r1,r1,8 <== NOT EXECUTED
ffc178f4: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc178f8: 4e 80 00 20 blr <== NOT EXECUTED
if (RTEMS_RFS_S_ISDIR (mode))
loc->handlers = rtems_rfs_rtems_handlers (dir);
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
loc->handlers = rtems_rfs_rtems_handlers (device);
else if (RTEMS_RFS_S_ISLNK (mode))
loc->handlers = rtems_rfs_rtems_handlers (link);
ffc178fc: 3d 20 ff c4 lis r9,-60
ffc17900: 38 09 ba f8 addi r0,r9,-17672
ffc17904: 90 03 00 08 stw r0,8(r3)
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
ffc17908: 38 60 00 01 li r3,1
}
ffc1790c: 80 01 00 0c lwz r0,12(r1)
ffc17910: 38 21 00 08 addi r1,r1,8
ffc17914: 7c 08 03 a6 mtlr r0
ffc17918: 4e 80 00 20 blr
rtems_rfs_inode_handle* inode)
{
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
if (RTEMS_RFS_S_ISDIR (mode))
loc->handlers = rtems_rfs_rtems_handlers (dir);
ffc1791c: 3d 20 ff c4 lis r9,-60
ffc17920: 38 09 dc e8 addi r0,r9,-8984
ffc17924: 90 03 00 08 stw r0,8(r3)
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
ffc17928: 38 60 00 01 li r3,1
}
ffc1792c: 80 01 00 0c lwz r0,12(r1)
ffc17930: 38 21 00 08 addi r1,r1,8
ffc17934: 7c 08 03 a6 mtlr r0
ffc17938: 4e 80 00 20 blr
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
loc->handlers = rtems_rfs_rtems_handlers (device);
else if (RTEMS_RFS_S_ISLNK (mode))
loc->handlers = rtems_rfs_rtems_handlers (link);
else if (RTEMS_RFS_S_ISREG (mode))
loc->handlers = rtems_rfs_rtems_handlers (file);
ffc1793c: 3d 20 ff c4 lis r9,-60
ffc17940: 38 09 dd 20 addi r0,r9,-8928
ffc17944: 90 03 00 08 stw r0,8(r3)
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
ffc17948: 38 60 00 01 li r3,1
}
ffc1794c: 80 01 00 0c lwz r0,12(r1)
ffc17950: 38 21 00 08 addi r1,r1,8
ffc17954: 7c 08 03 a6 mtlr r0
ffc17958: 4e 80 00 20 blr
ffc14b4c <rtems_rfs_rtems_shutdown>:
/**
* Shutdown the file system.
*/
int
rtems_rfs_rtems_shutdown (rtems_filesystem_mount_table_entry_t* mt_entry)
{
ffc14b4c: 94 21 ff f0 stwu r1,-16(r1)
ffc14b50: 7c 08 02 a6 mflr r0
ffc14b54: 90 01 00 14 stw r0,20(r1)
rtems_rfs_file_system* fs = mt_entry->fs_info;
ffc14b58: 80 63 00 34 lwz r3,52(r3)
/**
* Shutdown the file system.
*/
int
rtems_rfs_rtems_shutdown (rtems_filesystem_mount_table_entry_t* mt_entry)
{
ffc14b5c: 93 c1 00 08 stw r30,8(r1)
rtems_rfs_file_system* fs = mt_entry->fs_info;
rtems_rfs_rtems_private* rtems;
int rc;
rtems = rtems_rfs_fs_user (fs);
ffc14b60: 83 c3 00 7c lwz r30,124(r3)
/**
* Shutdown the file system.
*/
int
rtems_rfs_rtems_shutdown (rtems_filesystem_mount_table_entry_t* mt_entry)
{
ffc14b64: 93 e1 00 0c stw r31,12(r1)
rtems_rfs_rtems_private* rtems;
int rc;
rtems = rtems_rfs_fs_user (fs);
rc = rtems_rfs_fs_close(fs);
ffc14b68: 48 01 16 f9 bl ffc26260 <rtems_rfs_fs_close>
ffc14b6c: 7c 7f 1b 78 mr r31,r3
rtems_rfs_mutex_destroy (&rtems->access);
ffc14b70: 7f c3 f3 78 mr r3,r30
ffc14b74: 48 01 24 99 bl ffc2700c <rtems_rfs_mutex_destroy>
free (rtems);
ffc14b78: 7f c3 f3 78 mr r3,r30
ffc14b7c: 4b ff 39 65 bl ffc084e0 <free>
return rtems_rfs_rtems_error ("shutdown: close", rc);
ffc14b80: 48 01 50 e1 bl ffc29c60 <__errno>
ffc14b84: 2f 9f 00 00 cmpwi cr7,r31,0
ffc14b88: 93 e3 00 00 stw r31,0(r3)
ffc14b8c: 38 60 ff ff li r3,-1
ffc14b90: 40 9e 00 08 bne- cr7,ffc14b98 <rtems_rfs_rtems_shutdown+0x4c><== NEVER TAKEN
ffc14b94: 38 60 00 00 li r3,0
}
ffc14b98: 80 01 00 14 lwz r0,20(r1)
ffc14b9c: 83 c1 00 08 lwz r30,8(r1)
ffc14ba0: 7c 08 03 a6 mtlr r0
ffc14ba4: 83 e1 00 0c lwz r31,12(r1)
ffc14ba8: 38 21 00 10 addi r1,r1,16
ffc14bac: 4e 80 00 20 blr
ffc14a8c <rtems_rfs_rtems_statvfs>:
* @return int
*/
static int
rtems_rfs_rtems_statvfs (rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
ffc14a8c: 94 21 ff e0 stwu r1,-32(r1) <== NOT EXECUTED
ffc14a90: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc14a94: 90 01 00 24 stw r0,36(r1) <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
ffc14a98: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
*/
static int
rtems_rfs_rtems_statvfs (rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc14a9c: 81 23 00 10 lwz r9,16(r3) <== NOT EXECUTED
* @return int
*/
static int
rtems_rfs_rtems_statvfs (rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
ffc14aa0: 93 c1 00 18 stw r30,24(r1) <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc14aa4: 83 c9 00 34 lwz r30,52(r9) <== NOT EXECUTED
* @return int
*/
static int
rtems_rfs_rtems_statvfs (rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
ffc14aa8: 93 e1 00 1c stw r31,28(r1) <== NOT EXECUTED
ffc14aac: 7c 9f 23 78 mr r31,r4 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
ffc14ab0: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc14ab4: 38 81 00 0c addi r4,r1,12 <== NOT EXECUTED
ffc14ab8: 4b ff f3 4d bl ffc13e04 <rtems_rfs_group_usage> <== NOT EXECUTED
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
ffc14abc: 81 3e 00 0c lwz r9,12(r30) <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
ffc14ac0: 38 00 00 00 li r0,0 <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
ffc14ac4: 81 5e 00 04 lwz r10,4(r30) <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
ffc14ac8: 81 7e 00 10 lwz r11,16(r30) <== NOT EXECUTED
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
sb->f_flag = rtems_rfs_fs_flags (fs);
sb->f_namemax = rtems_rfs_fs_max_name (fs);
return 0;
}
ffc14acc: 38 60 00 00 li r3,0 <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
ffc14ad0: 80 9e 00 08 lwz r4,8(r30) <== NOT EXECUTED
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
ffc14ad4: 80 a9 00 24 lwz r5,36(r9) <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
ffc14ad8: 80 c9 00 1c lwz r6,28(r9) <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
sb->f_favail = sb->f_ffree;
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
sb->f_flag = rtems_rfs_fs_flags (fs);
ffc14adc: 80 fe 00 00 lwz r7,0(r30) <== NOT EXECUTED
sb->f_namemax = rtems_rfs_fs_max_name (fs);
ffc14ae0: 81 1e 00 18 lwz r8,24(r30) <== NOT EXECUTED
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
ffc14ae4: 90 1f 00 08 stw r0,8(r31) <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
ffc14ae8: 90 1f 00 10 stw r0,16(r31) <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
ffc14aec: 90 1f 00 18 stw r0,24(r31) <== NOT EXECUTED
sb->f_files = rtems_rfs_fs_inodes (fs);
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
sb->f_favail = sb->f_ffree;
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
ffc14af0: 3c 00 28 09 lis r0,10249 <== NOT EXECUTED
ffc14af4: 60 00 20 01 ori r0,r0,8193 <== NOT EXECUTED
ffc14af8: 90 1f 00 2c stw r0,44(r31) <== NOT EXECUTED
sb->f_flag = rtems_rfs_fs_flags (fs);
sb->f_namemax = rtems_rfs_fs_max_name (fs);
return 0;
}
ffc14afc: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
ffc14b00: 81 21 00 0c lwz r9,12(r1) <== NOT EXECUTED
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
sb->f_flag = rtems_rfs_fs_flags (fs);
sb->f_namemax = rtems_rfs_fs_max_name (fs);
return 0;
}
ffc14b04: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
ffc14b08: 90 9f 00 00 stw r4,0(r31) <== NOT EXECUTED
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
ffc14b0c: 7d 49 50 50 subf r10,r9,r10 <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
ffc14b10: 81 21 00 08 lwz r9,8(r1) <== NOT EXECUTED
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
ffc14b14: 90 bf 00 04 stw r5,4(r31) <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
ffc14b18: 7d 29 58 50 subf r9,r9,r11 <== NOT EXECUTED
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
ffc14b1c: 90 df 00 0c stw r6,12(r31) <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
ffc14b20: 91 5f 00 14 stw r10,20(r31) <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
ffc14b24: 91 5f 00 1c stw r10,28(r31) <== NOT EXECUTED
sb->f_files = rtems_rfs_fs_inodes (fs);
ffc14b28: 91 7f 00 20 stw r11,32(r31) <== NOT EXECUTED
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
ffc14b2c: 91 3f 00 24 stw r9,36(r31) <== NOT EXECUTED
sb->f_favail = sb->f_ffree;
ffc14b30: 91 3f 00 28 stw r9,40(r31) <== NOT EXECUTED
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
sb->f_flag = rtems_rfs_fs_flags (fs);
ffc14b34: 90 ff 00 30 stw r7,48(r31) <== NOT EXECUTED
sb->f_namemax = rtems_rfs_fs_max_name (fs);
ffc14b38: 91 1f 00 34 stw r8,52(r31) <== NOT EXECUTED
return 0;
}
ffc14b3c: 83 c1 00 18 lwz r30,24(r1) <== NOT EXECUTED
ffc14b40: 83 e1 00 1c lwz r31,28(r1) <== NOT EXECUTED
ffc14b44: 38 21 00 20 addi r1,r1,32 <== NOT EXECUTED
ffc14b48: 4e 80 00 20 blr <== NOT EXECUTED
ffc151e4 <rtems_rfs_rtems_symlink>:
static int
rtems_rfs_rtems_symlink (rtems_filesystem_location_info_t* parent_loc,
const char* link_name,
const char* node_name)
{
ffc151e4: 94 21 ff d8 stwu r1,-40(r1)
ffc151e8: 7c 08 02 a6 mflr r0
ffc151ec: 90 01 00 2c stw r0,44(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
ffc151f0: 81 23 00 10 lwz r9,16(r3)
static int
rtems_rfs_rtems_symlink (rtems_filesystem_location_info_t* parent_loc,
const char* link_name,
const char* node_name)
{
ffc151f4: 93 e1 00 24 stw r31,36(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
ffc151f8: 83 e9 00 34 lwz r31,52(r9)
static int
rtems_rfs_rtems_symlink (rtems_filesystem_location_info_t* parent_loc,
const char* link_name,
const char* node_name)
{
ffc151fc: 93 21 00 0c stw r25,12(r1)
ffc15200: 93 41 00 10 stw r26,16(r1)
ffc15204: 7c ba 2b 78 mr r26,r5
ffc15208: 93 61 00 14 stw r27,20(r1)
ffc1520c: 7c 9b 23 78 mr r27,r4
ffc15210: 93 81 00 18 stw r28,24(r1)
ffc15214: 93 a1 00 1c stw r29,28(r1)
ffc15218: 93 c1 00 20 stw r30,32(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
ffc1521c: 83 c3 00 00 lwz r30,0(r3)
uid_t uid;
gid_t gid;
int rc;
#if defined(RTEMS_POSIX_API)
uid = geteuid ();
ffc15220: 48 00 7a 8d bl ffc1ccac <geteuid>
ffc15224: 7c 7c 1b 78 mr r28,r3
gid = getegid ();
ffc15228: 48 00 7a 75 bl ffc1cc9c <getegid>
rtems_rfs_mutex_destroy (&rtems->access);
free (rtems);
return rtems_rfs_rtems_error ("shutdown: close", rc);
}
ffc1522c: 81 3f 00 7c lwz r9,124(r31)
gid_t gid;
int rc;
#if defined(RTEMS_POSIX_API)
uid = geteuid ();
gid = getegid ();
ffc15230: 7c 7d 1b 78 mr r29,r3
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
ffc15234: 38 80 00 00 li r4,0
ffc15238: 80 69 00 00 lwz r3,0(r9)
ffc1523c: 38 a0 00 00 li r5,0
ffc15240: 4b ff 85 4d bl ffc0d78c <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
ffc15244: 7c 79 1b 79 mr. r25,r3
ffc15248: 40 82 00 f0 bne- ffc15338 <rtems_rfs_rtems_symlink+0x154><== NEVER TAKEN
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_symlink (fs, node_name, strlen (node_name),
ffc1524c: 7f 43 d3 78 mr r3,r26
ffc15250: 48 01 68 79 bl ffc2bac8 <strlen>
ffc15254: 7c 79 1b 78 mr r25,r3
link_name, strlen (link_name),
ffc15258: 7f 63 db 78 mr r3,r27
ffc1525c: 48 01 68 6d bl ffc2bac8 <strlen>
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_symlink (fs, node_name, strlen (node_name),
ffc15260: 7f ca f3 78 mr r10,r30
link_name, strlen (link_name),
ffc15264: 7c 67 1b 78 mr r7,r3
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_symlink (fs, node_name, strlen (node_name),
ffc15268: 7f 44 d3 78 mr r4,r26
ffc1526c: 7f e3 fb 78 mr r3,r31
ffc15270: 7f 25 cb 78 mr r5,r25
ffc15274: 7f 66 db 78 mr r6,r27
ffc15278: 7f 88 e3 78 mr r8,r28
ffc1527c: 7f a9 eb 78 mr r9,r29
ffc15280: 48 01 17 9d bl ffc26a1c <rtems_rfs_symlink>
link_name, strlen (link_name),
uid, gid, parent);
if (rc)
ffc15284: 7c 7e 1b 79 mr. r30,r3
ffc15288: 41 82 00 5c beq- ffc152e4 <rtems_rfs_rtems_symlink+0x100><== ALWAYS TAKEN
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc1528c: 83 bf 00 7c lwz r29,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc15290: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc15294: 48 00 db 51 bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc15298: 80 7d 00 00 lwz r3,0(r29) <== NOT EXECUTED
ffc1529c: 4b ff 86 7d bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc152a0: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc152a4: 40 82 00 c8 bne- ffc1536c <rtems_rfs_rtems_symlink+0x188><== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("symlink: linking", rc);
ffc152a8: 48 01 49 b9 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc152ac: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc152b0: 93 c3 00 00 stw r30,0(r3) <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
ffc152b4: 80 01 00 2c lwz r0,44(r1)
ffc152b8: 7f e3 fb 78 mr r3,r31
ffc152bc: 83 21 00 0c lwz r25,12(r1)
ffc152c0: 7c 08 03 a6 mtlr r0
ffc152c4: 83 41 00 10 lwz r26,16(r1)
ffc152c8: 83 61 00 14 lwz r27,20(r1)
ffc152cc: 83 81 00 18 lwz r28,24(r1)
ffc152d0: 83 a1 00 1c lwz r29,28(r1)
ffc152d4: 83 c1 00 20 lwz r30,32(r1)
ffc152d8: 83 e1 00 24 lwz r31,36(r1)
ffc152dc: 38 21 00 28 addi r1,r1,40
ffc152e0: 4e 80 00 20 blr
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc152e4: 83 df 00 7c lwz r30,124(r31)
rtems_rfs_buffers_release (fs);
ffc152e8: 7f e3 fb 78 mr r3,r31
ffc152ec: 48 00 da f9 bl ffc22de4 <rtems_rfs_buffers_release>
return rtems_rfs_rtems_error ("symlink: linking", rc);
}
rtems_rfs_rtems_unlock (fs);
return 0;
ffc152f0: 3b e0 00 00 li r31,0
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc152f4: 80 7e 00 00 lwz r3,0(r30)
ffc152f8: 4b ff 86 21 bl ffc0d918 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc152fc: 7c 7e 1b 79 mr. r30,r3
ffc15300: 41 82 ff b4 beq+ ffc152b4 <rtems_rfs_rtems_symlink+0xd0><== ALWAYS TAKEN
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc15304: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc15308: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc1530c: 48 00 26 5d bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc15310: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc15314: 41 9e ff a0 beq+ cr7,ffc152b4 <rtems_rfs_rtems_symlink+0xd0><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc15318: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1531c: 48 00 75 21 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc15320: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc15324: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc15328: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc1532c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc15330: 48 01 5a 15 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc15334: 4b ff ff 80 b ffc152b4 <rtems_rfs_rtems_symlink+0xd0><== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc15338: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1533c: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc15340: 48 00 26 29 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc15344: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc15348: 41 9e ff 04 beq+ cr7,ffc1524c <rtems_rfs_rtems_symlink+0x68><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
ffc1534c: 7f 23 cb 78 mr r3,r25 <== NOT EXECUTED
ffc15350: 48 00 74 ed bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc15354: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc15358: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc1535c: 38 63 bb 30 addi r3,r3,-17616 <== NOT EXECUTED
ffc15360: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc15364: 48 01 59 e1 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc15368: 4b ff fe e4 b ffc1524c <rtems_rfs_rtems_symlink+0x68><== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc1536c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc15370: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc15374: 48 00 25 f5 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc15378: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1537c: 41 9e ff 2c beq+ cr7,ffc152a8 <rtems_rfs_rtems_symlink+0xc4><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc15380: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc15384: 48 00 74 b9 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc15388: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc1538c: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc15390: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc15394: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc15398: 48 01 59 ad bl ffc2ad44 <printf> <== NOT EXECUTED
ffc1539c: 4b ff ff 0c b ffc152a8 <rtems_rfs_rtems_symlink+0xc4><== NOT EXECUTED
ffc14bb0 <rtems_rfs_rtems_unlink>:
*/
static int
rtems_rfs_rtems_unlink (rtems_filesystem_location_info_t* parent_loc,
rtems_filesystem_location_info_t* loc)
{
ffc14bb0: 94 21 ff e0 stwu r1,-32(r1)
ffc14bb4: 7c 08 02 a6 mflr r0
ffc14bb8: 7c 6b 1b 78 mr r11,r3
ffc14bbc: 90 01 00 24 stw r0,36(r1)
ffc14bc0: 7c 89 23 78 mr r9,r4
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
ffc14bc4: 38 a0 00 00 li r5,0
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
ffc14bc8: 81 43 00 10 lwz r10,16(r3)
ffc14bcc: 38 80 00 00 li r4,0
*/
static int
rtems_rfs_rtems_unlink (rtems_filesystem_location_info_t* parent_loc,
rtems_filesystem_location_info_t* loc)
{
ffc14bd0: 93 e1 00 1c stw r31,28(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
ffc14bd4: 83 ea 00 34 lwz r31,52(r10)
*/
static int
rtems_rfs_rtems_unlink (rtems_filesystem_location_info_t* parent_loc,
rtems_filesystem_location_info_t* loc)
{
ffc14bd8: 93 61 00 0c stw r27,12(r1)
rtems_rfs_mutex_destroy (&rtems->access);
free (rtems);
return rtems_rfs_rtems_error ("shutdown: close", rc);
}
ffc14bdc: 81 5f 00 7c lwz r10,124(r31)
*/
static int
rtems_rfs_rtems_unlink (rtems_filesystem_location_info_t* parent_loc,
rtems_filesystem_location_info_t* loc)
{
ffc14be0: 93 81 00 10 stw r28,16(r1)
ffc14be4: 80 6a 00 00 lwz r3,0(r10)
ffc14be8: 93 a1 00 14 stw r29,20(r1)
ffc14bec: 93 c1 00 18 stw r30,24(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
ffc14bf0: 83 8b 00 00 lwz r28,0(r11)
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (loc);
ffc14bf4: 83 a9 00 00 lwz r29,0(r9)
uint32_t doff = rtems_rfs_rtems_get_pathloc_doff (loc);
ffc14bf8: 83 c9 00 04 lwz r30,4(r9)
ffc14bfc: 4b ff 8b 91 bl ffc0d78c <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
ffc14c00: 7c 7b 1b 79 mr. r27,r3
ffc14c04: 40 82 00 c8 bne- ffc14ccc <rtems_rfs_rtems_unlink+0x11c><== NEVER TAKEN
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_UNLINK))
printf("rtems-rfs-rtems: unlink: parent:%" PRId32 " doff:%" PRIu32 " ino:%" PRId32 "\n",
parent, doff, ino);
rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_denied);
ffc14c08: 7f c6 f3 78 mr r6,r30
ffc14c0c: 7f e3 fb 78 mr r3,r31
ffc14c10: 7f 84 e3 78 mr r4,r28
ffc14c14: 7f a5 eb 78 mr r5,r29
ffc14c18: 38 e0 00 00 li r7,0
ffc14c1c: 48 01 19 55 bl ffc26570 <rtems_rfs_unlink>
if (rc)
ffc14c20: 7c 7e 1b 79 mr. r30,r3
ffc14c24: 41 82 00 54 beq- ffc14c78 <rtems_rfs_rtems_unlink+0xc8> <== ALWAYS TAKEN
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc14c28: 83 bf 00 7c lwz r29,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc14c2c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc14c30: 48 00 e1 b5 bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc14c34: 80 7d 00 00 lwz r3,0(r29) <== NOT EXECUTED
ffc14c38: 4b ff 8c e1 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc14c3c: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc14c40: 40 82 00 c0 bne- ffc14d00 <rtems_rfs_rtems_unlink+0x150><== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("unlink: unlink inode", rc);
ffc14c44: 48 01 50 1d bl ffc29c60 <__errno> <== NOT EXECUTED
ffc14c48: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc14c4c: 93 c3 00 00 stw r30,0(r3) <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
ffc14c50: 80 01 00 24 lwz r0,36(r1)
ffc14c54: 7f e3 fb 78 mr r3,r31
ffc14c58: 83 61 00 0c lwz r27,12(r1)
ffc14c5c: 7c 08 03 a6 mtlr r0
ffc14c60: 83 81 00 10 lwz r28,16(r1)
ffc14c64: 83 a1 00 14 lwz r29,20(r1)
ffc14c68: 83 c1 00 18 lwz r30,24(r1)
ffc14c6c: 83 e1 00 1c lwz r31,28(r1)
ffc14c70: 38 21 00 20 addi r1,r1,32
ffc14c74: 4e 80 00 20 blr
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc14c78: 83 df 00 7c lwz r30,124(r31)
rtems_rfs_buffers_release (fs);
ffc14c7c: 7f e3 fb 78 mr r3,r31
ffc14c80: 48 00 e1 65 bl ffc22de4 <rtems_rfs_buffers_release>
return rtems_rfs_rtems_error ("unlink: unlink inode", rc);
}
rtems_rfs_rtems_unlock (fs);
return 0;
ffc14c84: 3b e0 00 00 li r31,0
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc14c88: 80 7e 00 00 lwz r3,0(r30)
ffc14c8c: 4b ff 8c 8d bl ffc0d918 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc14c90: 7c 7e 1b 79 mr. r30,r3
ffc14c94: 41 82 ff bc beq+ ffc14c50 <rtems_rfs_rtems_unlink+0xa0> <== ALWAYS TAKEN
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc14c98: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc14c9c: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc14ca0: 48 00 2c c9 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc14ca4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc14ca8: 41 9e ff a8 beq+ cr7,ffc14c50 <rtems_rfs_rtems_unlink+0xa0><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc14cac: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc14cb0: 48 00 7b 8d bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc14cb4: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc14cb8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc14cbc: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc14cc0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc14cc4: 48 01 60 81 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc14cc8: 4b ff ff 88 b ffc14c50 <rtems_rfs_rtems_unlink+0xa0> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc14ccc: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc14cd0: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc14cd4: 48 00 2c 95 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc14cd8: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc14cdc: 41 9e ff 2c beq+ cr7,ffc14c08 <rtems_rfs_rtems_unlink+0x58><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
ffc14ce0: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc14ce4: 48 00 7b 59 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc14ce8: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc14cec: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc14cf0: 38 63 bb 30 addi r3,r3,-17616 <== NOT EXECUTED
ffc14cf4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc14cf8: 48 01 60 4d bl ffc2ad44 <printf> <== NOT EXECUTED
ffc14cfc: 4b ff ff 0c b ffc14c08 <rtems_rfs_rtems_unlink+0x58> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc14d00: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc14d04: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc14d08: 48 00 2c 61 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc14d0c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc14d10: 41 9e ff 34 beq+ cr7,ffc14c44 <rtems_rfs_rtems_unlink+0x94><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc14d14: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc14d18: 48 00 7b 25 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc14d1c: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc14d20: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc14d24: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc14d28: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc14d2c: 48 01 60 19 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc14d30: 4b ff ff 14 b ffc14c44 <rtems_rfs_rtems_unlink+0x94> <== NOT EXECUTED
ffc155f0 <rtems_rfs_rtems_utime>:
static int
rtems_rfs_rtems_utime(rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
ffc155f0: 94 21 ff b0 stwu r1,-80(r1) <== NOT EXECUTED
ffc155f4: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc155f8: 7c 69 1b 78 mr r9,r3 <== NOT EXECUTED
ffc155fc: 90 01 00 54 stw r0,84(r1) <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc15600: 81 63 00 10 lwz r11,16(r3) <== NOT EXECUTED
static int
rtems_rfs_rtems_utime(rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
ffc15604: 93 e1 00 4c stw r31,76(r1) <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc15608: 83 eb 00 34 lwz r31,52(r11) <== NOT EXECUTED
static int
rtems_rfs_rtems_utime(rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
ffc1560c: 93 a1 00 44 stw r29,68(r1) <== NOT EXECUTED
ffc15610: 7c 9d 23 78 mr r29,r4 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
ffc15614: 38 80 00 00 li r4,0 <== NOT EXECUTED
rtems_rfs_mutex_destroy (&rtems->access);
free (rtems);
return rtems_rfs_rtems_error ("shutdown: close", rc);
}
ffc15618: 81 7f 00 7c lwz r11,124(r31) <== NOT EXECUTED
static int
rtems_rfs_rtems_utime(rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
ffc1561c: 93 c1 00 48 stw r30,72(r1) <== NOT EXECUTED
ffc15620: 7c be 2b 78 mr r30,r5 <== NOT EXECUTED
ffc15624: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc15628: 80 6b 00 00 lwz r3,0(r11) <== NOT EXECUTED
ffc1562c: 93 61 00 3c stw r27,60(r1) <== NOT EXECUTED
ffc15630: 93 81 00 40 stw r28,64(r1) <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
ffc15634: 83 89 00 00 lwz r28,0(r9) <== NOT EXECUTED
ffc15638: 4b ff 81 55 bl ffc0d78c <rtems_semaphore_obtain> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc1563c: 7c 7b 1b 79 mr. r27,r3 <== NOT EXECUTED
ffc15640: 40 82 01 6c bne- ffc157ac <rtems_rfs_rtems_utime+0x1bc> <== NOT EXECUTED
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc15644: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc15648: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1564c: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
ffc15650: 38 c0 00 01 li r6,1 <== NOT EXECUTED
ffc15654: 4b ff e9 85 bl ffc13fd8 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
ffc15658: 7c 7c 1b 79 mr. r28,r3 <== NOT EXECUTED
ffc1565c: 41 82 00 54 beq- ffc156b0 <rtems_rfs_rtems_utime+0xc0> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc15660: 83 df 00 7c lwz r30,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc15664: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc15668: 48 00 d7 7d bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc1566c: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc15670: 4b ff 82 a9 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc15674: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc15678: 40 82 01 68 bne- ffc157e0 <rtems_rfs_rtems_utime+0x1f0> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("utime: read inode", rc);
ffc1567c: 48 01 45 e5 bl ffc29c60 <__errno> <== NOT EXECUTED
ffc15680: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc15684: 93 83 00 00 stw r28,0(r3) <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
ffc15688: 80 01 00 54 lwz r0,84(r1) <== NOT EXECUTED
ffc1568c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc15690: 83 61 00 3c lwz r27,60(r1) <== NOT EXECUTED
ffc15694: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc15698: 83 81 00 40 lwz r28,64(r1) <== NOT EXECUTED
ffc1569c: 83 a1 00 44 lwz r29,68(r1) <== NOT EXECUTED
ffc156a0: 83 c1 00 48 lwz r30,72(r1) <== NOT EXECUTED
ffc156a4: 83 e1 00 4c lwz r31,76(r1) <== NOT EXECUTED
ffc156a8: 38 21 00 50 addi r1,r1,80 <== NOT EXECUTED
ffc156ac: 4e 80 00 20 blr <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
ffc156b0: 81 21 00 14 lwz r9,20(r1) <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
ffc156b4: 57 ca 46 3e rlwinm r10,r30,8,24,31 <== NOT EXECUTED
ffc156b8: 57 cb 84 3e rlwinm r11,r30,16,16,31 <== NOT EXECUTED
ffc156bc: 57 c0 c2 3e rlwinm r0,r30,24,8,31 <== NOT EXECUTED
ffc156c0: 9b c9 00 17 stb r30,23(r9) <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
ffc156c4: 57 a6 46 3e rlwinm r6,r29,8,24,31 <== NOT EXECUTED
ffc156c8: 57 a7 84 3e rlwinm r7,r29,16,16,31 <== NOT EXECUTED
ffc156cc: 98 c9 00 10 stb r6,16(r9) <== NOT EXECUTED
ffc156d0: 57 a8 c2 3e rlwinm r8,r29,24,8,31 <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
ffc156d4: 98 09 00 16 stb r0,22(r9) <== NOT EXECUTED
}
rtems_rfs_inode_set_atime (&inode, atime);
rtems_rfs_inode_set_mtime (&inode, mtime);
rc = rtems_rfs_inode_close (fs, &inode);
ffc156d8: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc156dc: 38 00 00 01 li r0,1 <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
ffc156e0: 98 e9 00 11 stb r7,17(r9) <== NOT EXECUTED
ffc156e4: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc156e8: 99 09 00 12 stb r8,18(r9) <== NOT EXECUTED
ffc156ec: 9b a9 00 13 stb r29,19(r9) <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
ffc156f0: 99 49 00 14 stb r10,20(r9) <== NOT EXECUTED
ffc156f4: 99 69 00 15 stb r11,21(r9) <== NOT EXECUTED
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc156f8: 98 01 00 18 stb r0,24(r1) <== NOT EXECUTED
ffc156fc: 4b ff eb 3d bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc)
ffc15700: 7c 7e 1b 79 mr. r30,r3 <== NOT EXECUTED
ffc15704: 41 82 00 54 beq- ffc15758 <rtems_rfs_rtems_utime+0x168> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc15708: 83 bf 00 7c lwz r29,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc1570c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc15710: 48 00 d6 d5 bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc15714: 80 7d 00 00 lwz r3,0(r29) <== NOT EXECUTED
ffc15718: 4b ff 82 01 bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc1571c: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc15720: 40 82 00 f4 bne- ffc15814 <rtems_rfs_rtems_utime+0x224> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("utime: closing inode", rc);
ffc15724: 48 01 45 3d bl ffc29c60 <__errno> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
ffc15728: 80 01 00 54 lwz r0,84(r1) <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
if (rc)
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("utime: closing inode", rc);
ffc1572c: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc15730: 93 c3 00 00 stw r30,0(r3) <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
ffc15734: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc15738: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1573c: 83 61 00 3c lwz r27,60(r1) <== NOT EXECUTED
ffc15740: 83 81 00 40 lwz r28,64(r1) <== NOT EXECUTED
ffc15744: 83 a1 00 44 lwz r29,68(r1) <== NOT EXECUTED
ffc15748: 83 c1 00 48 lwz r30,72(r1) <== NOT EXECUTED
ffc1574c: 83 e1 00 4c lwz r31,76(r1) <== NOT EXECUTED
ffc15750: 38 21 00 50 addi r1,r1,80 <== NOT EXECUTED
ffc15754: 4e 80 00 20 blr <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc15758: 83 df 00 7c lwz r30,124(r31) <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
ffc1575c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc15760: 48 00 d6 85 bl ffc22de4 <rtems_rfs_buffers_release> <== NOT EXECUTED
return rtems_rfs_rtems_error ("utime: closing inode", rc);
}
rtems_rfs_rtems_unlock (fs);
return 0;
ffc15764: 3b e0 00 00 li r31,0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
ffc15768: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc1576c: 4b ff 81 ad bl ffc0d918 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc15770: 7c 7e 1b 79 mr. r30,r3 <== NOT EXECUTED
ffc15774: 41 82 ff 14 beq+ ffc15688 <rtems_rfs_rtems_utime+0x98> <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc15778: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1577c: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc15780: 48 00 21 e9 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc15784: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc15788: 41 9e ff 00 beq+ cr7,ffc15688 <rtems_rfs_rtems_utime+0x98><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc1578c: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc15790: 48 00 70 ad bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc15794: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc15798: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc1579c: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc157a0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc157a4: 48 01 55 a1 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc157a8: 4b ff fe e0 b ffc15688 <rtems_rfs_rtems_utime+0x98> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc157ac: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc157b0: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc157b4: 48 00 21 b5 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc157b8: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc157bc: 41 9e fe 88 beq+ cr7,ffc15644 <rtems_rfs_rtems_utime+0x54><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
ffc157c0: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc157c4: 48 00 70 79 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc157c8: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc157cc: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc157d0: 38 63 bb 30 addi r3,r3,-17616 <== NOT EXECUTED
ffc157d4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc157d8: 48 01 55 6d bl ffc2ad44 <printf> <== NOT EXECUTED
ffc157dc: 4b ff fe 68 b ffc15644 <rtems_rfs_rtems_utime+0x54> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc157e0: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc157e4: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc157e8: 48 00 21 81 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc157ec: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc157f0: 41 9e fe 8c beq+ cr7,ffc1567c <rtems_rfs_rtems_utime+0x8c><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc157f4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc157f8: 48 00 70 45 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc157fc: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc15800: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc15804: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc15808: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1580c: 48 01 55 39 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc15810: 4b ff fe 6c b ffc1567c <rtems_rfs_rtems_utime+0x8c> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc15814: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc15818: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc1581c: 48 00 21 4d bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc15820: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc15824: 41 9e ff 00 beq+ cr7,ffc15724 <rtems_rfs_rtems_utime+0x134><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc15828: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1582c: 48 00 70 11 bl ffc1c83c <rtems_status_text> <== NOT EXECUTED
ffc15830: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc15834: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc15838: 38 63 bb 58 addi r3,r3,-17576 <== NOT EXECUTED
ffc1583c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc15840: 48 01 55 05 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc15844: 4b ff fe e0 b ffc15724 <rtems_rfs_rtems_utime+0x134> <== NOT EXECUTED
ffc12564 <rtems_rfs_rup_quotient>:
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
ffc12564: 7c 69 1b 79 mr. r9,r3 <== NOT EXECUTED
return 1;
ffc12568: 38 60 00 01 li r3,1 <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
ffc1256c: 4d 82 00 20 beqlr <== NOT EXECUTED
return 1;
return ((dividend - 1) / divisor) + 1;
ffc12570: 38 69 ff ff addi r3,r9,-1 <== NOT EXECUTED
ffc12574: 7c 63 23 96 divwu r3,r3,r4 <== NOT EXECUTED
ffc12578: 38 63 00 01 addi r3,r3,1 <== NOT EXECUTED
}
ffc1257c: 4e 80 00 20 blr <== NOT EXECUTED
ffc224c4 <rtems_rfs_scan_chain>:
*/
static rtems_rfs_buffer*
rtems_rfs_scan_chain (rtems_chain_control* chain,
uint32_t* count,
rtems_rfs_buffer_block block)
{
ffc224c4: 94 21 ff e0 stwu r1,-32(r1)
ffc224c8: 7c 08 02 a6 mflr r0
ffc224cc: 90 01 00 24 stw r0,36(r1)
ffc224d0: 93 81 00 10 stw r28,16(r1)
ffc224d4: 7c 9c 23 78 mr r28,r4
rtems_rfs_buffer* buffer;
rtems_chain_node* node;
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
ffc224d8: 38 80 00 80 li r4,128
*/
static rtems_rfs_buffer*
rtems_rfs_scan_chain (rtems_chain_control* chain,
uint32_t* count,
rtems_rfs_buffer_block block)
{
ffc224dc: 93 c1 00 18 stw r30,24(r1)
ffc224e0: 7c 7e 1b 78 mr r30,r3
rtems_rfs_buffer* buffer;
rtems_chain_node* node;
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
ffc224e4: 38 60 00 00 li r3,0
*/
static rtems_rfs_buffer*
rtems_rfs_scan_chain (rtems_chain_control* chain,
uint32_t* count,
rtems_rfs_buffer_block block)
{
ffc224e8: 93 a1 00 14 stw r29,20(r1)
ffc224ec: 7c bd 2b 78 mr r29,r5
ffc224f0: 93 e1 00 1c stw r31,28(r1)
ffc224f4: 93 61 00 0c stw r27,12(r1)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return _Chain_Tail( the_chain )->previous;
ffc224f8: 83 fe 00 08 lwz r31,8(r30)
rtems_rfs_buffer* buffer;
rtems_chain_node* node;
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
ffc224fc: 4b ff 54 6d bl ffc17968 <rtems_rfs_trace>
ffc22500: 2f 83 00 00 cmpwi cr7,r3,0
ffc22504: 40 9e 01 20 bne- cr7,ffc22624 <rtems_rfs_scan_chain+0x160><== NEVER TAKEN
printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
while (!rtems_chain_is_head (chain, node))
ffc22508: 7f 9f f0 00 cmpw cr7,r31,r30
ffc2250c: 41 9e 00 cc beq- cr7,ffc225d8 <rtems_rfs_scan_chain+0x114><== NEVER TAKEN
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
ffc22510: 3f 60 ff c4 lis r27,-60
ffc22514: 3b 7b c8 9c addi r27,r27,-14180
ffc22518: 48 00 00 1c b ffc22534 <rtems_rfs_scan_chain+0x70>
if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
ffc2251c: 80 1f 00 3c lwz r0,60(r31)
ffc22520: 7f 80 e8 00 cmpw cr7,r0,r29
ffc22524: 41 9e 00 40 beq- cr7,ffc22564 <rtems_rfs_scan_chain+0xa0>
true);
if ((rc > 0) && (rrc == 0))
rrc = rc;
return rrc;
}
ffc22528: 83 ff 00 04 lwz r31,4(r31)
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
while (!rtems_chain_is_head (chain, node))
ffc2252c: 7f 9f f0 00 cmpw cr7,r31,r30
ffc22530: 41 9e 00 a8 beq- cr7,ffc225d8 <rtems_rfs_scan_chain+0x114>
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
ffc22534: 38 60 00 00 li r3,0
ffc22538: 38 80 00 80 li r4,128
ffc2253c: 4b ff 54 2d bl ffc17968 <rtems_rfs_trace>
ffc22540: 2f 83 00 00 cmpwi cr7,r3,0
ffc22544: 41 9e ff d8 beq+ cr7,ffc2251c <rtems_rfs_scan_chain+0x58><== ALWAYS TAKEN
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
ffc22548: 80 9f 00 3c lwz r4,60(r31) <== NOT EXECUTED
ffc2254c: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc22550: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc22554: 48 00 87 f1 bl ffc2ad44 <printf> <== NOT EXECUTED
if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
ffc22558: 80 1f 00 3c lwz r0,60(r31) <== NOT EXECUTED
ffc2255c: 7f 80 e8 00 cmpw cr7,r0,r29 <== NOT EXECUTED
ffc22560: 40 9e ff c8 bne+ cr7,ffc22528 <rtems_rfs_scan_chain+0x64><== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
ffc22564: 38 60 00 00 li r3,0
ffc22568: 38 80 00 80 li r4,128
ffc2256c: 4b ff 53 fd bl ffc17968 <rtems_rfs_trace>
ffc22570: 2f 83 00 00 cmpwi cr7,r3,0
ffc22574: 41 be 00 18 beq+ cr7,ffc2258c <rtems_rfs_scan_chain+0xc8><== ALWAYS TAKEN
printf (": found block=%" PRIuPTR "\n",
ffc22578: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc2257c: 80 9f 00 3c lwz r4,60(r31) <== NOT EXECUTED
ffc22580: 38 63 c8 a4 addi r3,r3,-14172 <== NOT EXECUTED
ffc22584: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc22588: 48 00 87 bd bl ffc2ad44 <printf> <== NOT EXECUTED
((intptr_t)(buffer->user)));
(*count)--;
ffc2258c: 81 3c 00 00 lwz r9,0(r28)
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
ffc22590: 7f e3 fb 78 mr r3,r31
rtems_chain_extract (node);
rtems_chain_set_off_chain (node);
return buffer;
ffc22594: 7f fe fb 78 mr r30,r31
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf (": found block=%" PRIuPTR "\n",
((intptr_t)(buffer->user)));
(*count)--;
ffc22598: 38 09 ff ff addi r0,r9,-1
ffc2259c: 90 1c 00 00 stw r0,0(r28)
ffc225a0: 4b fe c2 39 bl ffc0e7d8 <_Chain_Extract>
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
ffc225a4: 38 00 00 00 li r0,0
ffc225a8: 90 1f 00 04 stw r0,4(r31)
ffc225ac: 90 1f 00 00 stw r0,0(r31)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf (": not found\n");
return NULL;
}
ffc225b0: 80 01 00 24 lwz r0,36(r1)
ffc225b4: 7f c3 f3 78 mr r3,r30
ffc225b8: 83 61 00 0c lwz r27,12(r1)
ffc225bc: 7c 08 03 a6 mtlr r0
ffc225c0: 83 81 00 10 lwz r28,16(r1)
ffc225c4: 83 a1 00 14 lwz r29,20(r1)
ffc225c8: 83 c1 00 18 lwz r30,24(r1)
ffc225cc: 83 e1 00 1c lwz r31,28(r1)
ffc225d0: 38 21 00 20 addi r1,r1,32
ffc225d4: 4e 80 00 20 blr
return buffer;
}
node = rtems_chain_previous (node);
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
ffc225d8: 38 60 00 00 li r3,0
ffc225dc: 38 80 00 80 li r4,128
ffc225e0: 4b ff 53 89 bl ffc17968 <rtems_rfs_trace>
printf (": not found\n");
return NULL;
ffc225e4: 3b c0 00 00 li r30,0
return buffer;
}
node = rtems_chain_previous (node);
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
ffc225e8: 2f 83 00 00 cmpwi cr7,r3,0
ffc225ec: 41 9e ff c4 beq+ cr7,ffc225b0 <rtems_rfs_scan_chain+0xec><== ALWAYS TAKEN
printf (": not found\n");
ffc225f0: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc225f4: 38 63 c8 b8 addi r3,r3,-14152 <== NOT EXECUTED
ffc225f8: 48 00 89 01 bl ffc2aef8 <puts> <== NOT EXECUTED
return NULL;
}
ffc225fc: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
ffc22600: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc22604: 83 61 00 0c lwz r27,12(r1) <== NOT EXECUTED
ffc22608: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc2260c: 83 81 00 10 lwz r28,16(r1) <== NOT EXECUTED
ffc22610: 83 a1 00 14 lwz r29,20(r1) <== NOT EXECUTED
ffc22614: 83 c1 00 18 lwz r30,24(r1) <== NOT EXECUTED
ffc22618: 83 e1 00 1c lwz r31,28(r1) <== NOT EXECUTED
ffc2261c: 38 21 00 20 addi r1,r1,32 <== NOT EXECUTED
ffc22620: 4e 80 00 20 blr <== NOT EXECUTED
rtems_chain_node* node;
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
ffc22624: 80 9c 00 00 lwz r4,0(r28) <== NOT EXECUTED
ffc22628: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc2262c: 7f a5 eb 78 mr r5,r29 <== NOT EXECUTED
ffc22630: 38 63 c8 6c addi r3,r3,-14228 <== NOT EXECUTED
ffc22634: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc22638: 48 00 87 0d bl ffc2ad44 <printf> <== NOT EXECUTED
ffc2263c: 4b ff fe cc b ffc22508 <rtems_rfs_scan_chain+0x44> <== NOT EXECUTED
ffc20638 <rtems_rfs_search_map_for_clear_bit.constprop.1>:
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
ffc20638: 94 21 ff c0 stwu r1,-64(r1)
ffc2063c: 7c 08 02 a6 mflr r0
ffc20640: 90 01 00 44 stw r0,68(r1)
rtems_rfs_bitmap_element* map_bits;
int map_index;
int map_offset;
int rc;
*found = false;
ffc20644: 38 00 00 00 li r0,0
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
ffc20648: 93 81 00 30 stw r28,48(r1)
ffc2064c: 7c dc 33 78 mr r28,r6
ffc20650: 93 a1 00 34 stw r29,52(r1)
ffc20654: 7c 9d 23 78 mr r29,r4
*found = false;
/*
* Load the bitmap.
*/
rc = rtems_rfs_bitmap_load_map (control, &map);
ffc20658: 38 81 00 08 addi r4,r1,8
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
ffc2065c: 93 c1 00 38 stw r30,56(r1)
ffc20660: 7c be 2b 78 mr r30,r5
ffc20664: 93 e1 00 3c stw r31,60(r1)
ffc20668: 7c 7f 1b 78 mr r31,r3
ffc2066c: 92 c1 00 18 stw r22,24(r1)
ffc20670: 92 e1 00 1c stw r23,28(r1)
ffc20674: 93 01 00 20 stw r24,32(r1)
ffc20678: 93 21 00 24 stw r25,36(r1)
ffc2067c: 93 41 00 28 stw r26,40(r1)
ffc20680: 93 61 00 2c stw r27,44(r1)
rtems_rfs_bitmap_element* map_bits;
int map_index;
int map_offset;
int rc;
*found = false;
ffc20684: 98 05 00 00 stb r0,0(r5)
/*
* Load the bitmap.
*/
rc = rtems_rfs_bitmap_load_map (control, &map);
ffc20688: 4b ff ff 39 bl ffc205c0 <rtems_rfs_bitmap_load_map>
if (rc > 0)
ffc2068c: 2c 03 00 00 cmpwi r3,0
ffc20690: 40 81 00 3c ble- ffc206cc <rtems_rfs_search_map_for_clear_bit.constprop.1+0x94><== ALWAYS TAKEN
}
while (((direction < 0) && (test_bit >= end_bit))
|| ((direction > 0) && (test_bit <= end_bit)));
return 0;
}
ffc20694: 80 01 00 44 lwz r0,68(r1) <== NOT EXECUTED
ffc20698: 82 c1 00 18 lwz r22,24(r1) <== NOT EXECUTED
ffc2069c: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc206a0: 82 e1 00 1c lwz r23,28(r1) <== NOT EXECUTED
ffc206a4: 83 01 00 20 lwz r24,32(r1) <== NOT EXECUTED
ffc206a8: 83 21 00 24 lwz r25,36(r1) <== NOT EXECUTED
ffc206ac: 83 41 00 28 lwz r26,40(r1) <== NOT EXECUTED
ffc206b0: 83 61 00 2c lwz r27,44(r1) <== NOT EXECUTED
ffc206b4: 83 81 00 30 lwz r28,48(r1) <== NOT EXECUTED
ffc206b8: 83 a1 00 34 lwz r29,52(r1) <== NOT EXECUTED
ffc206bc: 83 c1 00 38 lwz r30,56(r1) <== NOT EXECUTED
ffc206c0: 83 e1 00 3c lwz r31,60(r1) <== NOT EXECUTED
ffc206c4: 38 21 00 40 addi r1,r1,64 <== NOT EXECUTED
ffc206c8: 4e 80 00 20 blr <== NOT EXECUTED
return rc;
/*
* Calculate the bit we are testing plus the end point we search over.
*/
test_bit = *bit;
ffc206cc: 81 3d 00 00 lwz r9,0(r29)
end_bit = test_bit + (window * direction);
ffc206d0: 57 8a 58 28 rlwinm r10,r28,11,0,20
if (end_bit < 0)
ffc206d4: 7d 4a 4a 15 add. r10,r10,r9
ffc206d8: 41 80 01 f0 blt- ffc208c8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x290><== NEVER TAKEN
end_bit = 0;
else if (end_bit >= control->size)
ffc206dc: 81 7f 00 0c lwz r11,12(r31)
ffc206e0: 7f 8a 58 40 cmplw cr7,r10,r11
ffc206e4: 40 9c 01 b0 bge- cr7,ffc20894 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x25c><== ALWAYS TAKEN
end_bit = control->size - 1;
map_index = rtems_rfs_bitmap_map_index (test_bit);
ffc206e8: 7d 23 2e 70 srawi r3,r9,5
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
search_index = rtems_rfs_bitmap_map_index (map_index);
search_offset = rtems_rfs_bitmap_map_offset (map_index);
search_bits = &control->search_bits[search_index];
ffc206ec: 83 1f 00 14 lwz r24,20(r31)
else if (end_bit >= control->size)
end_bit = control->size - 1;
map_index = rtems_rfs_bitmap_map_index (test_bit);
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
search_index = rtems_rfs_bitmap_map_index (map_index);
ffc206f0: 7d 28 56 70 srawi r8,r9,10
search_offset = rtems_rfs_bitmap_map_offset (map_index);
search_bits = &control->search_bits[search_index];
map_bits = &map[map_index];
ffc206f4: 80 81 00 08 lwz r4,8(r1)
}
}
map_bits += direction;
map_index += direction;
map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
ffc206f8: 2c 9c 00 00 cmpwi cr1,r28,0
map_index = rtems_rfs_bitmap_map_index (test_bit);
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
search_index = rtems_rfs_bitmap_map_index (map_index);
search_offset = rtems_rfs_bitmap_map_offset (map_index);
search_bits = &control->search_bits[search_index];
ffc206fc: 55 08 10 3a rlwinm r8,r8,2,0,29
map_bits = &map[map_index];
ffc20700: 54 6b 10 3a rlwinm r11,r3,2,0,29
map_index = rtems_rfs_bitmap_map_index (test_bit);
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
search_index = rtems_rfs_bitmap_map_index (map_index);
search_offset = rtems_rfs_bitmap_map_offset (map_index);
search_bits = &control->search_bits[search_index];
ffc20704: 7f 18 42 14 add r24,r24,r8
end_bit = 0;
else if (end_bit >= control->size)
end_bit = control->size - 1;
map_index = rtems_rfs_bitmap_map_index (test_bit);
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
ffc20708: 55 20 06 fe clrlwi r0,r9,27
search_index = rtems_rfs_bitmap_map_index (map_index);
search_offset = rtems_rfs_bitmap_map_offset (map_index);
ffc2070c: 54 66 06 fe clrlwi r6,r3,27
search_bits = &control->search_bits[search_index];
map_bits = &map[map_index];
ffc20710: 7c 84 5a 14 add r4,r4,r11
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
ffc20714: 57 97 10 3a rlwinm r23,r28,2,0,29
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
ffc20718: 57 99 28 34 rlwinm r25,r28,5,0,26
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
ffc2071c: 39 00 00 01 li r8,1
/*
* If any bit is clear find that bit and then search the map element. If
* all bits are set there are no map bits so move to the next search
* element.
*/
if (!rtems_rfs_bitmap_match (*search_bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
ffc20720: 83 58 00 00 lwz r26,0(r24)
ffc20724: 2f 9a 00 00 cmpwi cr7,r26,0
ffc20728: 41 9e 00 98 beq- cr7,ffc207c0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x188><== NEVER TAKEN
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
ffc2072c: 7c bc 1a 14 add r5,r28,r3
ffc20730: 54 a5 28 34 rlwinm r5,r5,5,0,26
ffc20734: 39 85 00 1f addi r12,r5,31
* all bits are set there are no map bits so move to the next search
* element.
*/
if (!rtems_rfs_bitmap_match (*search_bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
{
while ((search_offset >= 0)
ffc20738: 2b 86 00 1f cmplwi cr7,r6,31
ffc2073c: 41 9d 00 ac bgt- cr7,ffc207e8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1b0><== NEVER TAKEN
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
ffc20740: 7d 1b 30 30 slw r27,r8,r6
if (!rtems_rfs_bitmap_match (*search_bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
{
while ((search_offset >= 0)
&& (search_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*search_bits, search_offset))
ffc20744: 7f 6b d0 39 and. r11,r27,r26
ffc20748: 41 82 00 4c beq- ffc20794 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x15c><== NEVER TAKEN
{
/*
* Find the clear bit in the map. Update the search map and map if
* found. We may find none are spare if searching up from the seed.
*/
while ((map_offset >= 0)
ffc2074c: 2b 80 00 1f cmplwi cr7,r0,31
ffc20750: 41 9d 00 44 bgt- cr7,ffc20794 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x15c><== NEVER TAKEN
&& (map_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*map_bits, map_offset))
ffc20754: 80 e4 00 00 lwz r7,0(r4)
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
ffc20758: 7d 0b 00 30 slw r11,r8,r0
* found. We may find none are spare if searching up from the seed.
*/
while ((map_offset >= 0)
&& (map_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*map_bits, map_offset))
ffc2075c: 7d 76 38 39 and. r22,r11,r7
ffc20760: 40 82 00 bc bne- ffc2081c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1e4>
*found = true;
rtems_rfs_buffer_mark_dirty (control->buffer);
return 0;
}
if (test_bit == end_bit)
ffc20764: 7f 8a 48 00 cmpw cr7,r10,r9
ffc20768: 40 be 00 10 bne+ cr7,ffc20778 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x140><== ALWAYS TAKEN
ffc2076c: 48 00 00 28 b ffc20794 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x15c><== NOT EXECUTED
* found. We may find none are spare if searching up from the seed.
*/
while ((map_offset >= 0)
&& (map_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*map_bits, map_offset))
ffc20770: 40 82 00 ac bne- ffc2081c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1e4>
*found = true;
rtems_rfs_buffer_mark_dirty (control->buffer);
return 0;
}
if (test_bit == end_bit)
ffc20774: 41 9a 00 20 beq- cr6,ffc20794 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x15c><== NEVER TAKEN
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
ffc20778: 7c 1c 02 14 add r0,r28,r0
{
/*
* Find the clear bit in the map. Update the search map and map if
* found. We may find none are spare if searching up from the seed.
*/
while ((map_offset >= 0)
ffc2077c: 2b 80 00 1f cmplwi cr7,r0,31
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
ffc20780: 7d 0b 00 30 slw r11,r8,r0
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
ffc20784: 7d 3c 4a 14 add r9,r28,r9
* found. We may find none are spare if searching up from the seed.
*/
while ((map_offset >= 0)
&& (map_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*map_bits, map_offset))
ffc20788: 7d 76 38 39 and. r22,r11,r7
*found = true;
rtems_rfs_buffer_mark_dirty (control->buffer);
return 0;
}
if (test_bit == end_bit)
ffc2078c: 7f 0a 48 00 cmpw cr6,r10,r9
{
/*
* Find the clear bit in the map. Update the search map and map if
* found. We may find none are spare if searching up from the seed.
*/
while ((map_offset >= 0)
ffc20790: 40 9d ff e0 ble+ cr7,ffc20770 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x138><== ALWAYS TAKEN
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
ffc20794: 7c 84 ba 14 add r4,r4,r23 <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
ffc20798: 7c 7c 1a 14 add r3,r28,r3 <== NOT EXECUTED
}
}
map_bits += direction;
map_index += direction;
map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
ffc2079c: 40 85 00 68 ble- cr1,ffc20804 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1cc><== NOT EXECUTED
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
|| ((direction > 0) && (test_bit >= end_bit)))
ffc207a0: 7f 8a 28 00 cmpw cr7,r10,r5 <== NOT EXECUTED
map_bits += direction;
map_index += direction;
map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
ffc207a4: 7c a9 2b 78 mr r9,r5 <== NOT EXECUTED
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
|| ((direction > 0) && (test_bit >= end_bit)))
ffc207a8: 40 9d 01 3c ble- cr7,ffc208e4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x2ac><== NOT EXECUTED
}
}
map_bits += direction;
map_index += direction;
map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
ffc207ac: 38 00 00 00 li r0,0 <== NOT EXECUTED
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
ffc207b0: 7c c6 e2 14 add r6,r6,r28 <== NOT EXECUTED
ffc207b4: 7d 8c ca 14 add r12,r12,r25 <== NOT EXECUTED
ffc207b8: 7c a5 ca 14 add r5,r5,r25 <== NOT EXECUTED
ffc207bc: 4b ff ff 7c b ffc20738 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x100><== NOT EXECUTED
*
* Align test_bit either up or down depending on the direction to next 32
* bit boundary.
*/
rtems_rfs_bitmap_bit bits_skipped;
test_bit &= ~((1 << RTEMS_RFS_ELEMENT_BITS_POWER_2) - 1);
ffc207c0: 55 29 00 34 rlwinm r9,r9,0,0,26 <== NOT EXECUTED
if (direction > 0)
ffc207c4: 40 85 00 ec ble- cr1,ffc208b0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x278><== NOT EXECUTED
{
bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
ffc207c8: 20 c6 00 20 subfic r6,r6,32 <== NOT EXECUTED
test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();
ffc207cc: 54 c0 28 34 rlwinm r0,r6,5,0,26 <== NOT EXECUTED
ffc207d0: 7d 20 4a 14 add r9,r0,r9 <== NOT EXECUTED
map_offset = 0;
ffc207d4: 38 00 00 00 li r0,0 <== NOT EXECUTED
* adds 1. Remember the logic is for subtraction.
*/
test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
map_offset = rtems_rfs_bitmap_element_bits () - 1;
}
map_bits += direction * bits_skipped;
ffc207d8: 7c dc 31 d6 mullw r6,r28,r6 <== NOT EXECUTED
ffc207dc: 54 cb 10 3a rlwinm r11,r6,2,0,29 <== NOT EXECUTED
ffc207e0: 7c 84 5a 14 add r4,r4,r11 <== NOT EXECUTED
map_index += direction * bits_skipped;
ffc207e4: 7c 63 32 14 add r3,r3,r6 <== NOT EXECUTED
}
search_bits += direction;
ffc207e8: 7f 18 ba 14 add r24,r24,r23 <== NOT EXECUTED
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
ffc207ec: 40 85 00 b0 ble- cr1,ffc2089c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x264><== NOT EXECUTED
}
while (((direction < 0) && (test_bit >= end_bit))
|| ((direction > 0) && (test_bit <= end_bit)));
ffc207f0: 40 85 00 e0 ble- cr1,ffc208d0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x298><== NOT EXECUTED
ffc207f4: 7f 8a 48 00 cmpw cr7,r10,r9 <== NOT EXECUTED
ffc207f8: 41 9c 00 d8 blt- cr7,ffc208d0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x298><== NOT EXECUTED
ffc207fc: 38 c0 00 00 li r6,0 <== NOT EXECUTED
ffc20800: 4b ff ff 20 b ffc20720 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xe8><== NOT EXECUTED
map_bits += direction;
map_index += direction;
map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
ffc20804: 7d 89 63 78 mr r9,r12 <== NOT EXECUTED
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
ffc20808: 41 86 00 0c beq- cr1,ffc20814 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1dc><== NOT EXECUTED
ffc2080c: 7f 8a 60 00 cmpw cr7,r10,r12 <== NOT EXECUTED
ffc20810: 40 9c 00 c8 bge- cr7,ffc208d8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x2a0><== NOT EXECUTED
}
}
map_bits += direction;
map_index += direction;
map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
ffc20814: 38 00 00 1f li r0,31 <== NOT EXECUTED
ffc20818: 4b ff ff 98 b ffc207b0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x178><== NOT EXECUTED
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
ffc2081c: 7c eb 58 78 andc r11,r7,r11
&& (map_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*map_bits, map_offset))
{
*map_bits = rtems_rfs_bitmap_set (*map_bits, 1 << map_offset);
if (rtems_rfs_bitmap_match(*map_bits,
ffc20820: 2f 8b 00 00 cmpwi cr7,r11,0
while ((map_offset >= 0)
&& (map_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*map_bits, map_offset))
{
*map_bits = rtems_rfs_bitmap_set (*map_bits, 1 << map_offset);
ffc20824: 91 64 00 00 stw r11,0(r4)
if (rtems_rfs_bitmap_match(*map_bits,
ffc20828: 40 9e 00 10 bne- cr7,ffc20838 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x200><== ALWAYS TAKEN
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
ffc2082c: 80 18 00 00 lwz r0,0(r24) <== NOT EXECUTED
ffc20830: 7c 1b d8 78 andc r27,r0,r27 <== NOT EXECUTED
if (!rtems_rfs_bitmap_test (*map_bits, map_offset))
{
*map_bits = rtems_rfs_bitmap_set (*map_bits, 1 << map_offset);
if (rtems_rfs_bitmap_match(*map_bits,
RTEMS_RFS_BITMAP_ELEMENT_SET))
*search_bits = rtems_rfs_bitmap_set (*search_bits,
ffc20834: 93 78 00 00 stw r27,0(r24) <== NOT EXECUTED
1 << search_offset);
control->free--;
ffc20838: 81 5f 00 10 lwz r10,16(r31)
*bit = test_bit;
*found = true;
ffc2083c: 38 00 00 01 li r0,1
rtems_rfs_buffer_mark_dirty (control->buffer);
ffc20840: 81 7f 00 00 lwz r11,0(r31)
return 0;
ffc20844: 38 60 00 00 li r3,0
*map_bits = rtems_rfs_bitmap_set (*map_bits, 1 << map_offset);
if (rtems_rfs_bitmap_match(*map_bits,
RTEMS_RFS_BITMAP_ELEMENT_SET))
*search_bits = rtems_rfs_bitmap_set (*search_bits,
1 << search_offset);
control->free--;
ffc20848: 39 4a ff ff addi r10,r10,-1
}
while (((direction < 0) && (test_bit >= end_bit))
|| ((direction > 0) && (test_bit <= end_bit)));
return 0;
}
ffc2084c: 82 c1 00 18 lwz r22,24(r1)
*map_bits = rtems_rfs_bitmap_set (*map_bits, 1 << map_offset);
if (rtems_rfs_bitmap_match(*map_bits,
RTEMS_RFS_BITMAP_ELEMENT_SET))
*search_bits = rtems_rfs_bitmap_set (*search_bits,
1 << search_offset);
control->free--;
ffc20850: 91 5f 00 10 stw r10,16(r31)
*bit = test_bit;
ffc20854: 91 3d 00 00 stw r9,0(r29)
*found = true;
ffc20858: 98 1e 00 00 stb r0,0(r30)
rtems_rfs_buffer_mark_dirty (control->buffer);
ffc2085c: 98 0b 00 00 stb r0,0(r11)
}
while (((direction < 0) && (test_bit >= end_bit))
|| ((direction > 0) && (test_bit <= end_bit)));
return 0;
}
ffc20860: 80 01 00 44 lwz r0,68(r1)
ffc20864: 82 e1 00 1c lwz r23,28(r1)
ffc20868: 7c 08 03 a6 mtlr r0
ffc2086c: 83 01 00 20 lwz r24,32(r1)
ffc20870: 83 21 00 24 lwz r25,36(r1)
ffc20874: 83 41 00 28 lwz r26,40(r1)
ffc20878: 83 61 00 2c lwz r27,44(r1)
ffc2087c: 83 81 00 30 lwz r28,48(r1)
ffc20880: 83 a1 00 34 lwz r29,52(r1)
ffc20884: 83 c1 00 38 lwz r30,56(r1)
ffc20888: 83 e1 00 3c lwz r31,60(r1)
ffc2088c: 38 21 00 40 addi r1,r1,64
ffc20890: 4e 80 00 20 blr
end_bit = test_bit + (window * direction);
if (end_bit < 0)
end_bit = 0;
else if (end_bit >= control->size)
end_bit = control->size - 1;
ffc20894: 39 4b ff ff addi r10,r11,-1
ffc20898: 4b ff fe 50 b ffc206e8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xb0>
search_bits += direction;
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
}
while (((direction < 0) && (test_bit >= end_bit))
|| ((direction > 0) && (test_bit <= end_bit)));
ffc2089c: 41 86 00 34 beq- cr1,ffc208d0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x298><== NOT EXECUTED
}
search_bits += direction;
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
}
while (((direction < 0) && (test_bit >= end_bit))
ffc208a0: 7f 8a 48 00 cmpw cr7,r10,r9 <== NOT EXECUTED
ffc208a4: 41 9d 00 2c bgt- cr7,ffc208d0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x298><== NOT EXECUTED
ffc208a8: 38 c0 00 1f li r6,31 <== NOT EXECUTED
ffc208ac: 4b ff fe 74 b ffc20720 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xe8><== NOT EXECUTED
bits_skipped = search_offset + 1;
/*
* Need to remove 1 for the rounding up. The above rounds down and
* adds 1. Remember the logic is for subtraction.
*/
test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
ffc208b0: 54 c0 28 34 rlwinm r0,r6,5,0,26 <== NOT EXECUTED
ffc208b4: 7c 00 00 f8 not r0,r0 <== NOT EXECUTED
ffc208b8: 7d 20 4a 14 add r9,r0,r9 <== NOT EXECUTED
test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();
map_offset = 0;
}
else
{
bits_skipped = search_offset + 1;
ffc208bc: 38 c6 00 01 addi r6,r6,1 <== NOT EXECUTED
/*
* Need to remove 1 for the rounding up. The above rounds down and
* adds 1. Remember the logic is for subtraction.
*/
test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
map_offset = rtems_rfs_bitmap_element_bits () - 1;
ffc208c0: 38 00 00 1f li r0,31 <== NOT EXECUTED
ffc208c4: 4b ff ff 14 b ffc207d8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1a0><== NOT EXECUTED
*/
test_bit = *bit;
end_bit = test_bit + (window * direction);
if (end_bit < 0)
end_bit = 0;
ffc208c8: 39 40 00 00 li r10,0 <== NOT EXECUTED
ffc208cc: 4b ff fe 1c b ffc206e8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xb0><== NOT EXECUTED
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
}
while (((direction < 0) && (test_bit >= end_bit))
|| ((direction > 0) && (test_bit <= end_bit)));
return 0;
ffc208d0: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc208d4: 4b ff fd c0 b ffc20694 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x5c><== NOT EXECUTED
}
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
ffc208d8: 7f 18 ba 14 add r24,r24,r23 <== NOT EXECUTED
}
}
map_bits += direction;
map_index += direction;
map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
ffc208dc: 38 00 00 1f li r0,31 <== NOT EXECUTED
ffc208e0: 4b ff ff c0 b ffc208a0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x268><== NOT EXECUTED
}
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
ffc208e4: 7f 18 ba 14 add r24,r24,r23 <== NOT EXECUTED
}
}
map_bits += direction;
map_index += direction;
map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
ffc208e8: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc208ec: 4b ff ff 04 b ffc207f0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1b8><== NOT EXECUTED
ffc26a1c <rtems_rfs_symlink>:
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
ffc26a1c: 94 21 ff 38 stwu r1,-200(r1)
ffc26a20: 7c 08 02 a6 mflr r0
ffc26a24: 93 81 00 b8 stw r28,184(r1)
ffc26a28: 7c 7c 1b 78 mr r28,r3
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
ffc26a2c: 38 60 00 02 li r3,2
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
ffc26a30: 93 c1 00 c0 stw r30,192(r1)
ffc26a34: 7c 9e 23 78 mr r30,r4
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
ffc26a38: 38 80 00 00 li r4,0
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
ffc26a3c: 93 01 00 a8 stw r24,168(r1)
ffc26a40: 7d 58 53 78 mr r24,r10
ffc26a44: 93 21 00 ac stw r25,172(r1)
ffc26a48: 7c b9 2b 78 mr r25,r5
ffc26a4c: 93 41 00 b0 stw r26,176(r1)
ffc26a50: 7d 1a 43 78 mr r26,r8
ffc26a54: 93 61 00 b4 stw r27,180(r1)
ffc26a58: 7d 3b 4b 78 mr r27,r9
ffc26a5c: 93 a1 00 bc stw r29,188(r1)
ffc26a60: 7c dd 33 78 mr r29,r6
ffc26a64: 93 e1 00 c4 stw r31,196(r1)
ffc26a68: 7c ff 3b 78 mr r31,r7
ffc26a6c: 90 01 00 cc stw r0,204(r1)
ffc26a70: 92 e1 00 a4 stw r23,164(r1)
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
ffc26a74: 4b ff 0e f5 bl ffc17968 <rtems_rfs_trace>
ffc26a78: 2f 83 00 00 cmpwi cr7,r3,0
ffc26a7c: 40 9e 00 4c bne- cr7,ffc26ac8 <rtems_rfs_symlink+0xac> <== NEVER TAKEN
printf (" link:");
for (c = 0; c < link_length; c++)
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
ffc26a80: 80 1c 00 08 lwz r0,8(r28)
return ENAMETOOLONG;
ffc26a84: 3b 20 00 5b li r25,91
printf (" link:");
for (c = 0; c < link_length; c++)
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
ffc26a88: 7f 9f 00 40 cmplw cr7,r31,r0
ffc26a8c: 41 9c 00 b0 blt- cr7,ffc26b3c <rtems_rfs_symlink+0x120> <== ALWAYS TAKEN
rtems_rfs_inode_set_block_offset (&inode, link_length);
rc = rtems_rfs_inode_close (fs, &inode);
return rc;
}
ffc26a90: 80 01 00 cc lwz r0,204(r1)
ffc26a94: 7f 23 cb 78 mr r3,r25
ffc26a98: 82 e1 00 a4 lwz r23,164(r1)
ffc26a9c: 7c 08 03 a6 mtlr r0
ffc26aa0: 83 01 00 a8 lwz r24,168(r1)
ffc26aa4: 83 21 00 ac lwz r25,172(r1)
ffc26aa8: 83 41 00 b0 lwz r26,176(r1)
ffc26aac: 83 61 00 b4 lwz r27,180(r1)
ffc26ab0: 83 81 00 b8 lwz r28,184(r1)
ffc26ab4: 83 a1 00 bc lwz r29,188(r1)
ffc26ab8: 83 c1 00 c0 lwz r30,192(r1)
ffc26abc: 83 e1 00 c4 lwz r31,196(r1)
ffc26ac0: 38 21 00 c8 addi r1,r1,200
ffc26ac4: 4e 80 00 20 blr
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
{
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
ffc26ac8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc26acc: 38 63 dc 14 addi r3,r3,-9196 <== NOT EXECUTED
ffc26ad0: 7f 04 c3 78 mr r4,r24 <== NOT EXECUTED
ffc26ad4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc26ad8: 48 00 42 6d bl ffc2ad44 <printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
ffc26adc: 2f 99 00 00 cmpwi cr7,r25,0 <== NOT EXECUTED
ffc26ae0: 40 9d 00 1c ble- cr7,ffc26afc <rtems_rfs_symlink+0xe0> <== NOT EXECUTED
ffc26ae4: 3a e0 00 00 li r23,0 <== NOT EXECUTED
printf ("%c", name[c]);
ffc26ae8: 7c 7e b8 ae lbzx r3,r30,r23 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
{
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
for (c = 0; c < length; c++)
ffc26aec: 3a f7 00 01 addi r23,r23,1 <== NOT EXECUTED
printf ("%c", name[c]);
ffc26af0: 48 00 43 11 bl ffc2ae00 <putchar> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
{
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
for (c = 0; c < length; c++)
ffc26af4: 7f 97 c8 00 cmpw cr7,r23,r25 <== NOT EXECUTED
ffc26af8: 40 9e ff f0 bne+ cr7,ffc26ae8 <rtems_rfs_symlink+0xcc> <== NOT EXECUTED
printf ("%c", name[c]);
printf (" link:");
ffc26afc: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc26b00: 38 63 dc 3c addi r3,r3,-9156 <== NOT EXECUTED
ffc26b04: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc26b08: 48 00 42 3d bl ffc2ad44 <printf> <== NOT EXECUTED
for (c = 0; c < link_length; c++)
ffc26b0c: 2f 9f 00 00 cmpwi cr7,r31,0 <== NOT EXECUTED
ffc26b10: 40 bd ff 70 ble- cr7,ffc26a80 <rtems_rfs_symlink+0x64> <== NOT EXECUTED
ffc26b14: 3b 20 00 00 li r25,0 <== NOT EXECUTED
printf ("%c", link[c]);
ffc26b18: 7c 7d c8 ae lbzx r3,r29,r25 <== NOT EXECUTED
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (" link:");
for (c = 0; c < link_length; c++)
ffc26b1c: 3b 39 00 01 addi r25,r25,1 <== NOT EXECUTED
printf ("%c", link[c]);
ffc26b20: 48 00 42 e1 bl ffc2ae00 <putchar> <== NOT EXECUTED
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (" link:");
for (c = 0; c < link_length; c++)
ffc26b24: 7f 99 f8 00 cmpw cr7,r25,r31 <== NOT EXECUTED
ffc26b28: 40 9e ff f0 bne+ cr7,ffc26b18 <rtems_rfs_symlink+0xfc> <== NOT EXECUTED
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
ffc26b2c: 80 1c 00 08 lwz r0,8(r28) <== NOT EXECUTED
return ENAMETOOLONG;
ffc26b30: 3b 20 00 5b li r25,91 <== NOT EXECUTED
printf (" link:");
for (c = 0; c < link_length; c++)
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
ffc26b34: 7f 9f 00 40 cmplw cr7,r31,r0 <== NOT EXECUTED
ffc26b38: 40 9c ff 58 bge+ cr7,ffc26a90 <rtems_rfs_symlink+0x74> <== NOT EXECUTED
return ENAMETOOLONG;
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
ffc26b3c: 7f c3 f3 78 mr r3,r30
ffc26b40: 48 00 4f 89 bl ffc2bac8 <strlen>
ffc26b44: 38 e0 00 00 li r7,0
ffc26b48: 7c 66 1b 78 mr r6,r3
ffc26b4c: 38 01 00 14 addi r0,r1,20
ffc26b50: 7f 83 e3 78 mr r3,r28
ffc26b54: 90 01 00 08 stw r0,8(r1)
ffc26b58: 7f 04 c3 78 mr r4,r24
ffc26b5c: 7f c5 f3 78 mr r5,r30
ffc26b60: 60 e7 a1 ff ori r7,r7,41471
ffc26b64: 39 00 00 01 li r8,1
ffc26b68: 7f 49 d3 78 mr r9,r26
ffc26b6c: 7f 6a db 78 mr r10,r27
ffc26b70: 4b fe da ed bl ffc1465c <rtems_rfs_inode_create>
RTEMS_RFS_S_SYMLINK,
1, uid, gid, &ino);
if (rc > 0)
ffc26b74: 7c 79 1b 79 mr. r25,r3
ffc26b78: 41 81 ff 18 bgt+ ffc26a90 <rtems_rfs_symlink+0x74> <== NEVER TAKEN
return rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc26b7c: 80 81 00 14 lwz r4,20(r1)
ffc26b80: 7f 83 e3 78 mr r3,r28
ffc26b84: 38 a1 00 24 addi r5,r1,36
ffc26b88: 38 c0 00 01 li r6,1
ffc26b8c: 4b fe d4 4d bl ffc13fd8 <rtems_rfs_inode_open>
if (rc > 0)
ffc26b90: 7c 79 1b 79 mr. r25,r3
ffc26b94: 41 81 fe fc bgt+ ffc26a90 <rtems_rfs_symlink+0x74> <== NEVER TAKEN
/*
* If the link length is less than the length of data union in the inode
* place the link into the data area else allocate a block and write the link
* to that.
*/
if (link_length < RTEMS_RFS_INODE_DATA_NAME_SIZE)
ffc26b98: 2b 9f 00 13 cmplwi cr7,r31,19
ffc26b9c: 41 9d 00 88 bgt- cr7,ffc26c24 <rtems_rfs_symlink+0x208> <== NEVER TAKEN
{
memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
ffc26ba0: 81 61 00 30 lwz r11,48(r1)
ffc26ba4: 3b c0 00 00 li r30,0
memcpy (inode.node->data.name, link, link_length);
ffc26ba8: 7f a4 eb 78 mr r4,r29
* place the link into the data area else allocate a block and write the link
* to that.
*/
if (link_length < RTEMS_RFS_INODE_DATA_NAME_SIZE)
{
memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
ffc26bac: 39 2b 00 1c addi r9,r11,28
ffc26bb0: 93 cb 00 1c stw r30,28(r11)
memcpy (inode.node->data.name, link, link_length);
ffc26bb4: 7d 23 4b 78 mr r3,r9
* place the link into the data area else allocate a block and write the link
* to that.
*/
if (link_length < RTEMS_RFS_INODE_DATA_NAME_SIZE)
{
memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
ffc26bb8: 93 cb 00 20 stw r30,32(r11)
memcpy (inode.node->data.name, link, link_length);
ffc26bbc: 7f e5 fb 78 mr r5,r31
* place the link into the data area else allocate a block and write the link
* to that.
*/
if (link_length < RTEMS_RFS_INODE_DATA_NAME_SIZE)
{
memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
ffc26bc0: 93 cb 00 24 stw r30,36(r11)
ffc26bc4: 93 cb 00 28 stw r30,40(r11)
ffc26bc8: 93 cb 00 2c stw r30,44(r11)
memcpy (inode.node->data.name, link, link_length);
ffc26bcc: 48 00 3d d1 bl ffc2a99c <memcpy>
* @param block_count The block count.
*/
static inline void
rtems_rfs_inode_set_block_count (rtems_rfs_inode_handle* handle, uint32_t block_count)
{
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
ffc26bd0: 81 21 00 30 lwz r9,48(r1)
ffc26bd4: 9b c9 00 0c stb r30,12(r9)
ffc26bd8: 81 21 00 30 lwz r9,48(r1)
ffc26bdc: 9b c9 00 0d stb r30,13(r9)
ffc26be0: 81 21 00 30 lwz r9,48(r1)
ffc26be4: 9b c9 00 0e stb r30,14(r9)
ffc26be8: 81 21 00 30 lwz r9,48(r1)
ffc26bec: 9b c9 00 0f stb r30,15(r9)
*/
static inline void
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,
uint16_t block_offset)
{
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
ffc26bf0: 81 21 00 30 lwz r9,48(r1)
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rtems_rfs_inode_set_block_offset (&inode, link_length);
ffc26bf4: 57 ff 04 3e clrlwi r31,r31,16
ffc26bf8: 57 e0 c2 3e rlwinm r0,r31,24,8,31
ffc26bfc: 98 09 00 0a stb r0,10(r9)
rc = rtems_rfs_inode_close (fs, &inode);
ffc26c00: 7f 83 e3 78 mr r3,r28
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc26c04: 38 00 00 01 li r0,1
*/
static inline void
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,
uint16_t block_offset)
{
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
ffc26c08: 81 21 00 30 lwz r9,48(r1)
ffc26c0c: 38 81 00 24 addi r4,r1,36
ffc26c10: 9b e9 00 0b stb r31,11(r9)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc26c14: 98 01 00 34 stb r0,52(r1)
ffc26c18: 4b fe d6 21 bl ffc14238 <rtems_rfs_inode_close>
ffc26c1c: 7c 79 1b 78 mr r25,r3
return rc;
ffc26c20: 4b ff fe 70 b ffc26a90 <rtems_rfs_symlink+0x74>
rtems_rfs_block_map map;
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
uint8_t* data;
rc = rtems_rfs_block_map_open (fs, &inode, &map);
ffc26c24: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc26c28: 38 81 00 24 addi r4,r1,36 <== NOT EXECUTED
ffc26c2c: 38 a1 00 4c addi r5,r1,76 <== NOT EXECUTED
ffc26c30: 4b ff a9 29 bl ffc21558 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
ffc26c34: 7c 79 1b 79 mr. r25,r3 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
ffc26c38: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
uint8_t* data;
rc = rtems_rfs_block_map_open (fs, &inode, &map);
if (rc > 0)
ffc26c3c: 40 81 00 10 ble- ffc26c4c <rtems_rfs_symlink+0x230> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
if (rc > 0)
{
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
ffc26c40: 38 81 00 24 addi r4,r1,36 <== NOT EXECUTED
ffc26c44: 4b fe d5 f5 bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
ffc26c48: 4b ff fe 48 b ffc26a90 <rtems_rfs_symlink+0x74> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
ffc26c4c: 38 81 00 4c addi r4,r1,76 <== NOT EXECUTED
ffc26c50: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc26c54: 38 c1 00 10 addi r6,r1,16 <== NOT EXECUTED
ffc26c58: 4b ff af c9 bl ffc21c20 <rtems_rfs_block_map_grow> <== NOT EXECUTED
if (rc > 0)
ffc26c5c: 7c 79 1b 79 mr. r25,r3 <== NOT EXECUTED
ffc26c60: 40 81 00 20 ble- ffc26c80 <rtems_rfs_symlink+0x264> <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
ffc26c64: 38 81 00 4c addi r4,r1,76 <== NOT EXECUTED
ffc26c68: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc26c6c: 4b ff aa f5 bl ffc21760 <rtems_rfs_block_map_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
ffc26c70: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc26c74: 38 81 00 24 addi r4,r1,36 <== NOT EXECUTED
ffc26c78: 4b fe d5 c1 bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
ffc26c7c: 4b ff fe 14 b ffc26a90 <rtems_rfs_symlink+0x74> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
ffc26c80: 80 a1 00 10 lwz r5,16(r1) <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
handle->bnum = 0;
ffc26c84: 3b c0 00 00 li r30,0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc26c88: 38 00 00 00 li r0,0 <== NOT EXECUTED
handle->bnum = 0;
ffc26c8c: 93 c1 00 1c stw r30,28(r1) <== NOT EXECUTED
ffc26c90: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc26c94: 38 81 00 18 addi r4,r1,24 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc26c98: 98 01 00 18 stb r0,24(r1) <== NOT EXECUTED
ffc26c9c: 38 c0 00 00 li r6,0 <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
ffc26ca0: 93 c1 00 20 stw r30,32(r1) <== NOT EXECUTED
ffc26ca4: 4b ff bb b1 bl ffc22854 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
if (rc > 0)
ffc26ca8: 7c 79 1b 79 mr. r25,r3 <== NOT EXECUTED
ffc26cac: 40 81 00 18 ble- ffc26cc4 <rtems_rfs_symlink+0x2a8> <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
ffc26cb0: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc26cb4: 38 81 00 4c addi r4,r1,76 <== NOT EXECUTED
ffc26cb8: 4b ff aa a9 bl ffc21760 <rtems_rfs_block_map_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
ffc26cbc: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc26cc0: 4b ff ff 80 b ffc26c40 <rtems_rfs_symlink+0x224> <== NOT EXECUTED
return rc;
}
data = rtems_rfs_buffer_data (&buffer);
ffc26cc4: 81 21 00 20 lwz r9,32(r1) <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
ffc26cc8: 38 80 00 ff li r4,255 <== NOT EXECUTED
ffc26ccc: 80 bc 00 08 lwz r5,8(r28) <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
data = rtems_rfs_buffer_data (&buffer);
ffc26cd0: 83 69 00 24 lwz r27,36(r9) <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
ffc26cd4: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc26cd8: 48 00 3e dd bl ffc2abb4 <memset> <== NOT EXECUTED
memcpy (data, link, link_length);
ffc26cdc: 7f e5 fb 78 mr r5,r31 <== NOT EXECUTED
ffc26ce0: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc26ce4: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc26ce8: 48 00 3c b5 bl ffc2a99c <memcpy> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc26cec: 38 81 00 18 addi r4,r1,24 <== NOT EXECUTED
ffc26cf0: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc26cf4: 4b ff b9 4d bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_close (fs, &map);
ffc26cf8: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc26cfc: 38 81 00 4c addi r4,r1,76 <== NOT EXECUTED
handle->dirty = false;
ffc26d00: 9b c1 00 18 stb r30,24(r1) <== NOT EXECUTED
handle->bnum = 0;
ffc26d04: 93 c1 00 1c stw r30,28(r1) <== NOT EXECUTED
handle->buffer = NULL;
ffc26d08: 93 c1 00 20 stw r30,32(r1) <== NOT EXECUTED
ffc26d0c: 4b ff aa 55 bl ffc21760 <rtems_rfs_block_map_close> <== NOT EXECUTED
if (rc > 0)
ffc26d10: 7c 79 1b 79 mr. r25,r3 <== NOT EXECUTED
ffc26d14: 40 81 fe dc ble+ ffc26bf0 <rtems_rfs_symlink+0x1d4> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
ffc26d18: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc26d1c: 38 81 00 24 addi r4,r1,36 <== NOT EXECUTED
ffc26d20: 4b fe d5 19 bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
ffc26d24: 4b ff fd 6c b ffc26a90 <rtems_rfs_symlink+0x74> <== NOT EXECUTED
ffc26d28 <rtems_rfs_symlink_read>:
rtems_rfs_symlink_read (rtems_rfs_file_system* fs,
rtems_rfs_ino link,
char* path,
size_t size,
size_t* length)
{
ffc26d28: 94 21 ff 50 stwu r1,-176(r1)
ffc26d2c: 7c 08 02 a6 mflr r0
ffc26d30: 93 c1 00 a8 stw r30,168(r1)
ffc26d34: 7c 9e 23 78 mr r30,r4
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
ffc26d38: 38 80 00 00 li r4,0
rtems_rfs_symlink_read (rtems_rfs_file_system* fs,
rtems_rfs_ino link,
char* path,
size_t size,
size_t* length)
{
ffc26d3c: 93 e1 00 ac stw r31,172(r1)
ffc26d40: 7c 7f 1b 78 mr r31,r3
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
ffc26d44: 38 60 00 04 li r3,4
rtems_rfs_symlink_read (rtems_rfs_file_system* fs,
rtems_rfs_ino link,
char* path,
size_t size,
size_t* length)
{
ffc26d48: 93 61 00 9c stw r27,156(r1)
ffc26d4c: 7c bb 2b 78 mr r27,r5
ffc26d50: 93 81 00 a0 stw r28,160(r1)
ffc26d54: 7c dc 33 78 mr r28,r6
ffc26d58: 93 a1 00 a4 stw r29,164(r1)
ffc26d5c: 7c fd 3b 78 mr r29,r7
ffc26d60: 90 01 00 b4 stw r0,180(r1)
ffc26d64: 93 41 00 98 stw r26,152(r1)
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
ffc26d68: 4b ff 0c 01 bl ffc17968 <rtems_rfs_trace>
ffc26d6c: 2f 83 00 00 cmpwi cr7,r3,0
ffc26d70: 40 9e 00 74 bne- cr7,ffc26de4 <rtems_rfs_symlink_read+0xbc><== NEVER TAKEN
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
rc = rtems_rfs_inode_open (fs, link, &inode, true);
ffc26d74: 7f e3 fb 78 mr r3,r31
ffc26d78: 7f c4 f3 78 mr r4,r30
ffc26d7c: 38 a1 00 18 addi r5,r1,24
ffc26d80: 38 c0 00 01 li r6,1
ffc26d84: 4b fe d2 55 bl ffc13fd8 <rtems_rfs_inode_open>
if (rc)
ffc26d88: 7c 7a 1b 79 mr. r26,r3
ffc26d8c: 40 82 00 2c bne- ffc26db8 <rtems_rfs_symlink_read+0x90> <== NEVER TAKEN
return rc;
if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))
ffc26d90: 80 81 00 24 lwz r4,36(r1)
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
ffc26d94: 89 24 00 02 lbz r9,2(r4)
ffc26d98: 55 29 44 26 rlwinm r9,r9,8,16,19
ffc26d9c: 6d 20 ff ff xoris r0,r9,65535
ffc26da0: 2f 80 a0 00 cmpwi cr7,r0,-24576
ffc26da4: 41 9e 00 58 beq- cr7,ffc26dfc <rtems_rfs_symlink_read+0xd4><== ALWAYS TAKEN
*length = rtems_rfs_inode_get_block_offset (&inode);
if (size < *length)
{
rtems_rfs_inode_close (fs, &inode);
ffc26da8: 7f e3 fb 78 mr r3,r31
ffc26dac: 38 81 00 18 addi r4,r1,24
ffc26db0: 4b fe d4 89 bl ffc14238 <rtems_rfs_inode_close>
return EINVAL;
ffc26db4: 3b 40 00 16 li r26,22
path[*length] = '\0';
rc = rtems_rfs_inode_close (fs, &inode);
return rc;
}
ffc26db8: 80 01 00 b4 lwz r0,180(r1)
ffc26dbc: 7f 43 d3 78 mr r3,r26
ffc26dc0: 83 61 00 9c lwz r27,156(r1)
ffc26dc4: 7c 08 03 a6 mtlr r0
ffc26dc8: 83 41 00 98 lwz r26,152(r1)
ffc26dcc: 83 81 00 a0 lwz r28,160(r1)
ffc26dd0: 83 a1 00 a4 lwz r29,164(r1)
ffc26dd4: 83 c1 00 a8 lwz r30,168(r1)
ffc26dd8: 83 e1 00 ac lwz r31,172(r1)
ffc26ddc: 38 21 00 b0 addi r1,r1,176
ffc26de0: 4e 80 00 20 blr
{
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
ffc26de4: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc26de8: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc26dec: 38 63 dc 44 addi r3,r3,-9148 <== NOT EXECUTED
ffc26df0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc26df4: 48 00 3f 51 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc26df8: 4b ff ff 7c b ffc26d74 <rtems_rfs_symlink_read+0x4c> <== NOT EXECUTED
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
ffc26dfc: 88 a4 00 0a lbz r5,10(r4)
ffc26e00: 88 04 00 0b lbz r0,11(r4)
ffc26e04: 54 a5 40 2e rlwinm r5,r5,8,0,23
{
rtems_rfs_inode_close (fs, &inode);
return EINVAL;
}
*length = rtems_rfs_inode_get_block_offset (&inode);
ffc26e08: 7c a5 03 78 or r5,r5,r0
if (size < *length)
ffc26e0c: 7f 85 e0 40 cmplw cr7,r5,r28
{
rtems_rfs_inode_close (fs, &inode);
return EINVAL;
}
*length = rtems_rfs_inode_get_block_offset (&inode);
ffc26e10: 90 bd 00 00 stw r5,0(r29)
if (size < *length)
ffc26e14: 41 bd ff 94 bgt- cr7,ffc26da8 <rtems_rfs_symlink_read+0x80>
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
ffc26e18: 89 44 00 0c lbz r10,12(r4)
ffc26e1c: 89 24 00 0d lbz r9,13(r4)
ffc26e20: 89 64 00 0f lbz r11,15(r4)
ffc26e24: 55 4a c0 0e rlwinm r10,r10,24,0,7
ffc26e28: 55 29 80 1e rlwinm r9,r9,16,0,15
ffc26e2c: 88 04 00 0e lbz r0,14(r4)
ffc26e30: 7d 49 4b 78 or r9,r10,r9
ffc26e34: 7d 29 5b 78 or r9,r9,r11
ffc26e38: 54 00 40 2e rlwinm r0,r0,8,0,23
{
rtems_rfs_inode_close (fs, &inode);
return EINVAL;
}
if (rtems_rfs_inode_get_block_count (&inode) == 0)
ffc26e3c: 7d 2b 03 79 or. r11,r9,r0
ffc26e40: 40 82 00 30 bne- ffc26e70 <rtems_rfs_symlink_read+0x148><== NEVER TAKEN
{
memcpy (path, inode.node->data.name, *length);
ffc26e44: 7f 63 db 78 mr r3,r27
ffc26e48: 38 84 00 1c addi r4,r4,28
ffc26e4c: 48 00 3b 51 bl ffc2a99c <memcpy>
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
path[*length] = '\0';
ffc26e50: 80 1d 00 00 lwz r0,0(r29)
ffc26e54: 39 20 00 00 li r9,0
rc = rtems_rfs_inode_close (fs, &inode);
ffc26e58: 7f e3 fb 78 mr r3,r31
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
path[*length] = '\0';
ffc26e5c: 7d 3b 01 ae stbx r9,r27,r0
rc = rtems_rfs_inode_close (fs, &inode);
ffc26e60: 38 81 00 18 addi r4,r1,24
ffc26e64: 4b fe d3 d5 bl ffc14238 <rtems_rfs_inode_close>
ffc26e68: 7c 7a 1b 78 mr r26,r3
return rc;
ffc26e6c: 4b ff ff 4c b ffc26db8 <rtems_rfs_symlink_read+0x90>
rtems_rfs_block_map map;
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
char* data;
rc = rtems_rfs_block_map_open (fs, &inode, &map);
ffc26e70: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc26e74: 38 81 00 18 addi r4,r1,24 <== NOT EXECUTED
ffc26e78: 38 a1 00 40 addi r5,r1,64 <== NOT EXECUTED
ffc26e7c: 4b ff a6 dd bl ffc21558 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
ffc26e80: 7c 7a 1b 79 mr. r26,r3 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
ffc26e84: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
char* data;
rc = rtems_rfs_block_map_open (fs, &inode, &map);
if (rc > 0)
ffc26e88: 40 81 00 10 ble- ffc26e98 <rtems_rfs_symlink_read+0x170><== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
if (rc > 0)
{
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
ffc26e8c: 38 81 00 18 addi r4,r1,24 <== NOT EXECUTED
ffc26e90: 4b fe d3 a9 bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
ffc26e94: 4b ff ff 24 b ffc26db8 <rtems_rfs_symlink_read+0x90> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
ffc26e98: 38 81 00 40 addi r4,r1,64 <== NOT EXECUTED
ffc26e9c: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc26ea0: 38 c0 00 00 li r6,0 <== NOT EXECUTED
ffc26ea4: 38 e1 00 08 addi r7,r1,8 <== NOT EXECUTED
ffc26ea8: 4b ff ac 75 bl ffc21b1c <rtems_rfs_block_map_seek> <== NOT EXECUTED
if (rc > 0)
ffc26eac: 7c 7a 1b 79 mr. r26,r3 <== NOT EXECUTED
ffc26eb0: 40 81 00 20 ble- ffc26ed0 <rtems_rfs_symlink_read+0x1a8><== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
ffc26eb4: 38 81 00 40 addi r4,r1,64 <== NOT EXECUTED
ffc26eb8: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc26ebc: 4b ff a8 a5 bl ffc21760 <rtems_rfs_block_map_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
ffc26ec0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc26ec4: 38 81 00 18 addi r4,r1,24 <== NOT EXECUTED
ffc26ec8: 4b fe d3 71 bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
ffc26ecc: 4b ff fe ec b ffc26db8 <rtems_rfs_symlink_read+0x90> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
ffc26ed0: 80 a1 00 08 lwz r5,8(r1) <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
handle->bnum = 0;
ffc26ed4: 3b c0 00 00 li r30,0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc26ed8: 38 00 00 00 li r0,0 <== NOT EXECUTED
handle->bnum = 0;
ffc26edc: 93 c1 00 10 stw r30,16(r1) <== NOT EXECUTED
ffc26ee0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc26ee4: 38 81 00 0c addi r4,r1,12 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc26ee8: 98 01 00 0c stb r0,12(r1) <== NOT EXECUTED
ffc26eec: 38 c0 00 00 li r6,0 <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
ffc26ef0: 93 c1 00 14 stw r30,20(r1) <== NOT EXECUTED
ffc26ef4: 4b ff b9 61 bl ffc22854 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
if (rc > 0)
ffc26ef8: 7c 7a 1b 79 mr. r26,r3 <== NOT EXECUTED
ffc26efc: 40 81 00 18 ble- ffc26f14 <rtems_rfs_symlink_read+0x1ec><== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
ffc26f00: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc26f04: 38 81 00 40 addi r4,r1,64 <== NOT EXECUTED
ffc26f08: 4b ff a8 59 bl ffc21760 <rtems_rfs_block_map_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
ffc26f0c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc26f10: 4b ff ff 7c b ffc26e8c <rtems_rfs_symlink_read+0x164><== NOT EXECUTED
return rc;
}
data = rtems_rfs_buffer_data (&buffer);
memcpy (path, data, *length);
ffc26f14: 81 21 00 14 lwz r9,20(r1) <== NOT EXECUTED
ffc26f18: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc26f1c: 80 bd 00 00 lwz r5,0(r29) <== NOT EXECUTED
ffc26f20: 80 89 00 24 lwz r4,36(r9) <== NOT EXECUTED
ffc26f24: 48 00 3a 79 bl ffc2a99c <memcpy> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
ffc26f28: 38 81 00 0c addi r4,r1,12 <== NOT EXECUTED
ffc26f2c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc26f30: 4b ff b7 11 bl ffc22640 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_close (fs, &map);
ffc26f34: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc26f38: 38 81 00 40 addi r4,r1,64 <== NOT EXECUTED
handle->dirty = false;
ffc26f3c: 9b c1 00 0c stb r30,12(r1) <== NOT EXECUTED
handle->bnum = 0;
ffc26f40: 93 c1 00 10 stw r30,16(r1) <== NOT EXECUTED
handle->buffer = NULL;
ffc26f44: 93 c1 00 14 stw r30,20(r1) <== NOT EXECUTED
ffc26f48: 4b ff a8 19 bl ffc21760 <rtems_rfs_block_map_close> <== NOT EXECUTED
if (rc > 0)
ffc26f4c: 7c 7a 1b 79 mr. r26,r3 <== NOT EXECUTED
ffc26f50: 40 81 ff 00 ble+ ffc26e50 <rtems_rfs_symlink_read+0x128><== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
ffc26f54: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc26f58: 38 81 00 18 addi r4,r1,24 <== NOT EXECUTED
ffc26f5c: 4b fe d2 dd bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
ffc26f60: 4b ff fe 58 b ffc26db8 <rtems_rfs_symlink_read+0x90> <== NOT EXECUTED
ffc179bc <rtems_rfs_trace_clear_mask>:
rtems_rfs_trace_mask
rtems_rfs_trace_clear_mask (rtems_rfs_trace_mask mask)
{
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
ffc179bc: 3d 20 00 00 lis r9,0 <== NOT EXECUTED
ffc179c0: 39 69 2a 68 addi r11,r9,10856 <== NOT EXECUTED
ffc179c4: 81 49 2a 68 lwz r10,10856(r9) <== NOT EXECUTED
ffc179c8: 80 0b 00 04 lwz r0,4(r11) <== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
ffc179cc: 7d 43 18 78 andc r3,r10,r3 <== NOT EXECUTED
ffc179d0: 7c 04 20 78 andc r4,r0,r4 <== NOT EXECUTED
ffc179d4: 90 69 2a 68 stw r3,10856(r9) <== NOT EXECUTED
return state;
}
ffc179d8: 7d 43 53 78 mr r3,r10 <== NOT EXECUTED
rtems_rfs_trace_mask
rtems_rfs_trace_clear_mask (rtems_rfs_trace_mask mask)
{
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
rtems_rfs_trace_flags &= ~mask;
ffc179dc: 90 8b 00 04 stw r4,4(r11) <== NOT EXECUTED
return state;
}
ffc179e0: 7c 04 03 78 mr r4,r0 <== NOT EXECUTED
ffc179e4: 4e 80 00 20 blr <== NOT EXECUTED
ffc17990 <rtems_rfs_trace_set_mask>:
rtems_rfs_trace_mask
rtems_rfs_trace_set_mask (rtems_rfs_trace_mask mask)
{
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
ffc17990: 3d 20 00 00 lis r9,0 <== NOT EXECUTED
ffc17994: 39 69 2a 68 addi r11,r9,10856 <== NOT EXECUTED
ffc17998: 81 49 2a 68 lwz r10,10856(r9) <== NOT EXECUTED
ffc1799c: 80 0b 00 04 lwz r0,4(r11) <== NOT EXECUTED
rtems_rfs_trace_flags |= mask;
ffc179a0: 7c 63 53 78 or r3,r3,r10 <== NOT EXECUTED
ffc179a4: 7c 84 03 78 or r4,r4,r0 <== NOT EXECUTED
ffc179a8: 90 69 2a 68 stw r3,10856(r9) <== NOT EXECUTED
return state;
}
ffc179ac: 7d 43 53 78 mr r3,r10 <== NOT EXECUTED
rtems_rfs_trace_mask
rtems_rfs_trace_set_mask (rtems_rfs_trace_mask mask)
{
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
rtems_rfs_trace_flags |= mask;
ffc179b0: 90 8b 00 04 stw r4,4(r11) <== NOT EXECUTED
return state;
}
ffc179b4: 7c 04 03 78 mr r4,r0 <== NOT EXECUTED
ffc179b8: 4e 80 00 20 blr <== NOT EXECUTED
ffc179e8 <rtems_rfs_trace_shell_command>:
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
ffc179e8: 94 21 ff 10 stwu r1,-240(r1) <== NOT EXECUTED
ffc179ec: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
const char* table[] =
ffc179f0: 38 a0 00 98 li r5,152 <== NOT EXECUTED
return state;
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
ffc179f4: 93 01 00 d0 stw r24,208(r1) <== NOT EXECUTED
ffc179f8: 7c 98 23 78 mr r24,r4 <== NOT EXECUTED
const char* table[] =
ffc179fc: 3c 80 ff c4 lis r4,-60 <== NOT EXECUTED
return state;
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
ffc17a00: 93 21 00 d4 stw r25,212(r1) <== NOT EXECUTED
const char* table[] =
ffc17a04: 38 84 bb a4 addi r4,r4,-17500 <== NOT EXECUTED
return state;
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
ffc17a08: 7c 79 1b 78 mr r25,r3 <== NOT EXECUTED
const char* table[] =
ffc17a0c: 38 61 00 08 addi r3,r1,8 <== NOT EXECUTED
return state;
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
ffc17a10: 90 01 00 f4 stw r0,244(r1) <== NOT EXECUTED
ffc17a14: 91 c1 00 a8 stw r14,168(r1) <== NOT EXECUTED
ffc17a18: 91 e1 00 ac stw r15,172(r1) <== NOT EXECUTED
ffc17a1c: 92 01 00 b0 stw r16,176(r1) <== NOT EXECUTED
ffc17a20: 92 21 00 b4 stw r17,180(r1) <== NOT EXECUTED
ffc17a24: 92 41 00 b8 stw r18,184(r1) <== NOT EXECUTED
ffc17a28: 92 61 00 bc stw r19,188(r1) <== NOT EXECUTED
ffc17a2c: 92 81 00 c0 stw r20,192(r1) <== NOT EXECUTED
ffc17a30: 92 a1 00 c4 stw r21,196(r1) <== NOT EXECUTED
ffc17a34: 92 c1 00 c8 stw r22,200(r1) <== NOT EXECUTED
ffc17a38: 92 e1 00 cc stw r23,204(r1) <== NOT EXECUTED
ffc17a3c: 93 41 00 d8 stw r26,216(r1) <== NOT EXECUTED
ffc17a40: 93 61 00 dc stw r27,220(r1) <== NOT EXECUTED
ffc17a44: 93 81 00 e0 stw r28,224(r1) <== NOT EXECUTED
ffc17a48: 93 a1 00 e4 stw r29,228(r1) <== NOT EXECUTED
ffc17a4c: 93 c1 00 e8 stw r30,232(r1) <== NOT EXECUTED
ffc17a50: 93 e1 00 ec stw r31,236(r1) <== NOT EXECUTED
const char* table[] =
ffc17a54: 48 01 2f 49 bl ffc2a99c <memcpy> <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
ffc17a58: 2f 99 00 01 cmpwi cr7,r25,1 <== NOT EXECUTED
rtems_rfs_trace_flags |= set_value;
rtems_rfs_trace_flags &= ~clear_value;
}
}
return 0;
ffc17a5c: 38 60 00 00 li r3,0 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
ffc17a60: 40 9d 01 0c ble- cr7,ffc17b6c <rtems_rfs_trace_shell_command+0x184><== NOT EXECUTED
{
if (argv[arg][0] == '-')
ffc17a64: 82 d8 00 04 lwz r22,4(r24) <== NOT EXECUTED
ffc17a68: 88 16 00 00 lbz r0,0(r22) <== NOT EXECUTED
ffc17a6c: 2f 80 00 2d cmpwi cr7,r0,45 <== NOT EXECUTED
ffc17a70: 41 9e 01 e4 beq- cr7,ffc17c54 <rtems_rfs_trace_shell_command+0x26c><== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
return 0;
default:
printf ("error: unknown option\n");
return 1;
ffc17a74: 3e 20 00 00 lis r17,0 <== NOT EXECUTED
ffc17a78: 3a 31 2a 68 addi r17,r17,10856 <== NOT EXECUTED
ffc17a7c: 3d e0 ff c4 lis r15,-60 <== NOT EXECUTED
ffc17a80: 83 d1 00 00 lwz r30,0(r17) <== NOT EXECUTED
ffc17a84: 3e 00 ff c4 lis r16,-60 <== NOT EXECUTED
ffc17a88: 83 f1 00 04 lwz r31,4(r17) <== NOT EXECUTED
{
if (strcmp (argv[arg], "set") == 0)
set = true;
if (strcmp (argv[arg], "clear") == 0)
set = false;
else if (strcmp (argv[arg], "all") == 0)
ffc17a8c: 3d c0 ff c4 lis r14,-60 <== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
return state;
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
ffc17a90: 3a 78 00 04 addi r19,r24,4 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
ffc17a94: 3a 80 00 01 li r20,1 <== NOT EXECUTED
"file-io"
};
rtems_rfs_trace_mask set_value = 0;
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
ffc17a98: 3a 40 00 01 li r18,1 <== NOT EXECUTED
"file-close",
"file-io"
};
rtems_rfs_trace_mask set_value = 0;
rtems_rfs_trace_mask clear_value = 0;
ffc17a9c: 3b 80 00 00 li r28,0 <== NOT EXECUTED
ffc17aa0: 3b a0 00 00 li r29,0 <== NOT EXECUTED
"file-open",
"file-close",
"file-io"
};
rtems_rfs_trace_mask set_value = 0;
ffc17aa4: 3b 40 00 00 li r26,0 <== NOT EXECUTED
ffc17aa8: 3b 60 00 00 li r27,0 <== NOT EXECUTED
ffc17aac: 39 ef bc ac addi r15,r15,-17236 <== NOT EXECUTED
ffc17ab0: 3a 10 bc b0 addi r16,r16,-17232 <== NOT EXECUTED
{
if (strcmp (argv[arg], "set") == 0)
set = true;
if (strcmp (argv[arg], "clear") == 0)
set = false;
else if (strcmp (argv[arg], "all") == 0)
ffc17ab4: 39 ce e1 d4 addi r14,r14,-7724 <== NOT EXECUTED
ffc17ab8: 48 00 00 3c b ffc17af4 <rtems_rfs_trace_shell_command+0x10c><== NOT EXECUTED
}
else
{
if (strcmp (argv[arg], "set") == 0)
set = true;
if (strcmp (argv[arg], "clear") == 0)
ffc17abc: 7f c9 d3 78 or r9,r30,r26 <== NOT EXECUTED
ffc17ac0: 7f e0 db 78 or r0,r31,r27 <== NOT EXECUTED
ffc17ac4: 7d 3e e0 78 andc r30,r9,r28 <== NOT EXECUTED
ffc17ac8: 7c 1f e8 78 andc r31,r0,r29 <== NOT EXECUTED
set = false;
ffc17acc: 3a 40 00 00 li r18,0 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
ffc17ad0: 3a 94 00 01 addi r20,r20,1 <== NOT EXECUTED
}
}
}
rtems_rfs_trace_flags |= set_value;
rtems_rfs_trace_flags &= ~clear_value;
ffc17ad4: 93 d1 00 00 stw r30,0(r17) <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
ffc17ad8: 7f 94 c8 00 cmpw cr7,r20,r25 <== NOT EXECUTED
}
}
}
rtems_rfs_trace_flags |= set_value;
rtems_rfs_trace_flags &= ~clear_value;
ffc17adc: 93 f1 00 04 stw r31,4(r17) <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
ffc17ae0: 41 9e 00 88 beq- cr7,ffc17b68 <rtems_rfs_trace_shell_command+0x180><== NOT EXECUTED
{
if (argv[arg][0] == '-')
ffc17ae4: 86 d3 00 04 lwzu r22,4(r19) <== NOT EXECUTED
ffc17ae8: 88 16 00 00 lbz r0,0(r22) <== NOT EXECUTED
ffc17aec: 2f 80 00 2d cmpwi cr7,r0,45 <== NOT EXECUTED
ffc17af0: 41 9e 01 64 beq- cr7,ffc17c54 <rtems_rfs_trace_shell_command+0x26c><== NOT EXECUTED
return 1;
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
ffc17af4: 7e c3 b3 78 mr r3,r22 <== NOT EXECUTED
ffc17af8: 7d e4 7b 78 mr r4,r15 <== NOT EXECUTED
ffc17afc: 48 01 39 f1 bl ffc2b4ec <strcmp> <== NOT EXECUTED
ffc17b00: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc17b04: 40 9e 00 08 bne- cr7,ffc17b0c <rtems_rfs_trace_shell_command+0x124><== NOT EXECUTED
set = true;
ffc17b08: 3a 40 00 01 li r18,1 <== NOT EXECUTED
if (strcmp (argv[arg], "clear") == 0)
ffc17b0c: 7e c3 b3 78 mr r3,r22 <== NOT EXECUTED
ffc17b10: 7e 04 83 78 mr r4,r16 <== NOT EXECUTED
ffc17b14: 48 01 39 d9 bl ffc2b4ec <strcmp> <== NOT EXECUTED
ffc17b18: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc17b1c: 41 be ff a0 beq- cr7,ffc17abc <rtems_rfs_trace_shell_command+0xd4><== NOT EXECUTED
set = false;
else if (strcmp (argv[arg], "all") == 0)
ffc17b20: 7e c3 b3 78 mr r3,r22 <== NOT EXECUTED
ffc17b24: 7d c4 73 78 mr r4,r14 <== NOT EXECUTED
ffc17b28: 48 01 39 c5 bl ffc2b4ec <strcmp> <== NOT EXECUTED
{
if (set)
ffc17b2c: 3a a1 00 04 addi r21,r1,4 <== NOT EXECUTED
{
if (strcmp (argv[arg], "set") == 0)
set = true;
if (strcmp (argv[arg], "clear") == 0)
set = false;
else if (strcmp (argv[arg], "all") == 0)
ffc17b30: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc17b34: 3a e0 00 00 li r23,0 <== NOT EXECUTED
ffc17b38: 40 9e 00 94 bne- cr7,ffc17bcc <rtems_rfs_trace_shell_command+0x1e4><== NOT EXECUTED
{
if (set)
ffc17b3c: 2f 92 00 00 cmpwi cr7,r18,0 <== NOT EXECUTED
ffc17b40: 41 9e 00 d0 beq- cr7,ffc17c10 <rtems_rfs_trace_shell_command+0x228><== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
ffc17b44: 3a 94 00 01 addi r20,r20,1 <== NOT EXECUTED
ffc17b48: 7f 94 c8 00 cmpw cr7,r20,r25 <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
set = false;
else if (strcmp (argv[arg], "all") == 0)
{
if (set)
ffc17b4c: 7f 9e e0 f8 not r30,r28 <== NOT EXECUTED
ffc17b50: 7f bf e8 f8 not r31,r29 <== NOT EXECUTED
}
}
}
rtems_rfs_trace_flags |= set_value;
rtems_rfs_trace_flags &= ~clear_value;
ffc17b54: 93 d1 00 00 stw r30,0(r17) <== NOT EXECUTED
if (strcmp (argv[arg], "clear") == 0)
set = false;
else if (strcmp (argv[arg], "all") == 0)
{
if (set)
set_value = RTEMS_RFS_TRACE_ALL;
ffc17b58: 3b 40 ff ff li r26,-1 <== NOT EXECUTED
ffc17b5c: 3b 60 ff ff li r27,-1 <== NOT EXECUTED
}
}
}
rtems_rfs_trace_flags |= set_value;
rtems_rfs_trace_flags &= ~clear_value;
ffc17b60: 93 f1 00 04 stw r31,4(r17) <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
ffc17b64: 40 9e ff 80 bne+ cr7,ffc17ae4 <rtems_rfs_trace_shell_command+0xfc><== NOT EXECUTED
rtems_rfs_trace_flags |= set_value;
rtems_rfs_trace_flags &= ~clear_value;
}
}
return 0;
ffc17b68: 38 60 00 00 li r3,0 <== NOT EXECUTED
}
ffc17b6c: 80 01 00 f4 lwz r0,244(r1) <== NOT EXECUTED
ffc17b70: 81 c1 00 a8 lwz r14,168(r1) <== NOT EXECUTED
ffc17b74: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc17b78: 81 e1 00 ac lwz r15,172(r1) <== NOT EXECUTED
ffc17b7c: 82 01 00 b0 lwz r16,176(r1) <== NOT EXECUTED
ffc17b80: 82 21 00 b4 lwz r17,180(r1) <== NOT EXECUTED
ffc17b84: 82 41 00 b8 lwz r18,184(r1) <== NOT EXECUTED
ffc17b88: 82 61 00 bc lwz r19,188(r1) <== NOT EXECUTED
ffc17b8c: 82 81 00 c0 lwz r20,192(r1) <== NOT EXECUTED
ffc17b90: 82 a1 00 c4 lwz r21,196(r1) <== NOT EXECUTED
ffc17b94: 82 c1 00 c8 lwz r22,200(r1) <== NOT EXECUTED
ffc17b98: 82 e1 00 cc lwz r23,204(r1) <== NOT EXECUTED
ffc17b9c: 83 01 00 d0 lwz r24,208(r1) <== NOT EXECUTED
ffc17ba0: 83 21 00 d4 lwz r25,212(r1) <== NOT EXECUTED
ffc17ba4: 83 41 00 d8 lwz r26,216(r1) <== NOT EXECUTED
ffc17ba8: 83 61 00 dc lwz r27,220(r1) <== NOT EXECUTED
ffc17bac: 83 81 00 e0 lwz r28,224(r1) <== NOT EXECUTED
ffc17bb0: 83 a1 00 e4 lwz r29,228(r1) <== NOT EXECUTED
ffc17bb4: 83 c1 00 e8 lwz r30,232(r1) <== NOT EXECUTED
ffc17bb8: 83 e1 00 ec lwz r31,236(r1) <== NOT EXECUTED
ffc17bbc: 38 21 00 f0 addi r1,r1,240 <== NOT EXECUTED
ffc17bc0: 4e 80 00 20 blr <== NOT EXECUTED
else
clear_value = RTEMS_RFS_TRACE_ALL;
}
else
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
ffc17bc4: 3a f7 00 01 addi r23,r23,1 <== NOT EXECUTED
ffc17bc8: 41 9a 00 5c beq- cr6,ffc17c24 <rtems_rfs_trace_shell_command+0x23c><== NOT EXECUTED
{
if (strcmp (argv[arg], table[t]) == 0)
ffc17bcc: 84 95 00 04 lwzu r4,4(r21) <== NOT EXECUTED
ffc17bd0: 7e c3 b3 78 mr r3,r22 <== NOT EXECUTED
ffc17bd4: 48 01 39 19 bl ffc2b4ec <strcmp> <== NOT EXECUTED
else
clear_value = RTEMS_RFS_TRACE_ALL;
}
else
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
ffc17bd8: 2f 17 00 25 cmpwi cr6,r23,37 <== NOT EXECUTED
{
if (strcmp (argv[arg], table[t]) == 0)
ffc17bdc: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc17be0: 40 9e ff e4 bne+ cr7,ffc17bc4 <rtems_rfs_trace_shell_command+0x1dc><== NOT EXECUTED
{
if (set)
ffc17be4: 2f 92 00 00 cmpwi cr7,r18,0 <== NOT EXECUTED
set_value = 1 << t;
ffc17be8: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc17bec: 7c 17 b8 30 slw r23,r0,r23 <== NOT EXECUTED
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
{
if (strcmp (argv[arg], table[t]) == 0)
{
if (set)
ffc17bf0: 41 9e 00 48 beq- cr7,ffc17c38 <rtems_rfs_trace_shell_command+0x250><== NOT EXECUTED
set_value = 1 << t;
ffc17bf4: 7e fa fe 70 srawi r26,r23,31 <== NOT EXECUTED
ffc17bf8: 7f 49 f3 78 or r9,r26,r30 <== NOT EXECUTED
ffc17bfc: 7e e0 fb 78 or r0,r23,r31 <== NOT EXECUTED
ffc17c00: 7e fb bb 78 mr r27,r23 <== NOT EXECUTED
ffc17c04: 7d 3e e0 78 andc r30,r9,r28 <== NOT EXECUTED
ffc17c08: 7c 1f e8 78 andc r31,r0,r29 <== NOT EXECUTED
ffc17c0c: 4b ff fe c4 b ffc17ad0 <rtems_rfs_trace_shell_command+0xe8><== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
set = false;
else if (strcmp (argv[arg], "all") == 0)
{
if (set)
ffc17c10: 3b c0 00 00 li r30,0 <== NOT EXECUTED
ffc17c14: 3b e0 00 00 li r31,0 <== NOT EXECUTED
set_value = RTEMS_RFS_TRACE_ALL;
else
clear_value = RTEMS_RFS_TRACE_ALL;
ffc17c18: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
ffc17c1c: 3b a0 ff ff li r29,-1 <== NOT EXECUTED
ffc17c20: 4b ff fe b0 b ffc17ad0 <rtems_rfs_trace_shell_command+0xe8><== NOT EXECUTED
}
else
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
ffc17c24: 7f c9 d3 78 or r9,r30,r26 <== NOT EXECUTED
ffc17c28: 7f e0 db 78 or r0,r31,r27 <== NOT EXECUTED
ffc17c2c: 7d 3e e0 78 andc r30,r9,r28 <== NOT EXECUTED
ffc17c30: 7c 1f e8 78 andc r31,r0,r29 <== NOT EXECUTED
ffc17c34: 4b ff fe 9c b ffc17ad0 <rtems_rfs_trace_shell_command+0xe8><== NOT EXECUTED
if (strcmp (argv[arg], table[t]) == 0)
{
if (set)
set_value = 1 << t;
else
clear_value = 1 << t;
ffc17c38: 7e fc fe 70 srawi r28,r23,31 <== NOT EXECUTED
ffc17c3c: 7f c9 d3 78 or r9,r30,r26 <== NOT EXECUTED
ffc17c40: 7f e0 db 78 or r0,r31,r27 <== NOT EXECUTED
ffc17c44: 7e fd bb 78 mr r29,r23 <== NOT EXECUTED
ffc17c48: 7d 3e e0 78 andc r30,r9,r28 <== NOT EXECUTED
ffc17c4c: 7c 1f b8 78 andc r31,r0,r23 <== NOT EXECUTED
ffc17c50: 4b ff fe 80 b ffc17ad0 <rtems_rfs_trace_shell_command+0xe8><== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
{
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
ffc17c54: 88 16 00 01 lbz r0,1(r22) <== NOT EXECUTED
ffc17c58: 2f 80 00 68 cmpwi cr7,r0,104 <== NOT EXECUTED
ffc17c5c: 41 9e 00 20 beq- cr7,ffc17c7c <rtems_rfs_trace_shell_command+0x294><== NOT EXECUTED
ffc17c60: 2f 80 00 6c cmpwi cr7,r0,108 <== NOT EXECUTED
ffc17c64: 41 9e 00 34 beq- cr7,ffc17c98 <rtems_rfs_trace_shell_command+0x2b0><== NOT EXECUTED
printf ("%s: valid flags to set or clear are:\n", argv[0]);
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
return 0;
default:
printf ("error: unknown option\n");
ffc17c68: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc17c6c: 38 63 bc 94 addi r3,r3,-17260 <== NOT EXECUTED
ffc17c70: 48 01 32 89 bl ffc2aef8 <puts> <== NOT EXECUTED
return 1;
ffc17c74: 38 60 00 01 li r3,1 <== NOT EXECUTED
ffc17c78: 4b ff fe f4 b ffc17b6c <rtems_rfs_trace_shell_command+0x184><== NOT EXECUTED
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
{
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
ffc17c7c: 80 98 00 00 lwz r4,0(r24) <== NOT EXECUTED
ffc17c80: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc17c84: 38 63 bc 3c addi r3,r3,-17348 <== NOT EXECUTED
ffc17c88: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc17c8c: 48 01 30 b9 bl ffc2ad44 <printf> <== NOT EXECUTED
return 0;
ffc17c90: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc17c94: 4b ff fe d8 b ffc17b6c <rtems_rfs_trace_shell_command+0x184><== NOT EXECUTED
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
ffc17c98: 80 98 00 00 lwz r4,0(r24) <== NOT EXECUTED
ffc17c9c: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc17ca0: 38 63 bc 64 addi r3,r3,-17308 <== NOT EXECUTED
ffc17ca4: 3f 80 ff c4 lis r28,-60 <== NOT EXECUTED
ffc17ca8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc17cac: 48 01 30 99 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc17cb0: 3b c1 00 04 addi r30,r1,4 <== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
return state;
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
ffc17cb4: 3b 41 00 9c addi r26,r1,156 <== NOT EXECUTED
ffc17cb8: 3b 9c bc 8c addi r28,r28,-17268 <== NOT EXECUTED
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
return 0;
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
ffc17cbc: 84 9e 00 04 lwzu r4,4(r30) <== NOT EXECUTED
ffc17cc0: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc17cc4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc17cc8: 48 01 30 7d bl ffc2ad44 <printf> <== NOT EXECUTED
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
return 0;
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
ffc17ccc: 7f 9e d0 00 cmpw cr7,r30,r26 <== NOT EXECUTED
ffc17cd0: 40 9e ff ec bne+ cr7,ffc17cbc <rtems_rfs_trace_shell_command+0x2d4><== NOT EXECUTED
rtems_rfs_trace_flags |= set_value;
rtems_rfs_trace_flags &= ~clear_value;
}
}
return 0;
ffc17cd4: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc17cd8: 4b ff fe 94 b ffc17b6c <rtems_rfs_trace_shell_command+0x184><== NOT EXECUTED
ffc26570 <rtems_rfs_unlink>:
rtems_rfs_unlink (rtems_rfs_file_system* fs,
rtems_rfs_ino parent,
rtems_rfs_ino target,
uint32_t doff,
rtems_rfs_unlink_dir dir_mode)
{
ffc26570: 94 21 ff 88 stwu r1,-120(r1)
ffc26574: 7d 80 00 26 mfcr r12
ffc26578: 7c 08 02 a6 mflr r0
ffc2657c: 93 a1 00 6c stw r29,108(r1)
ffc26580: 7c 9d 23 78 mr r29,r4
rtems_rfs_inode_handle target_inode;
uint16_t links;
bool dir;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
ffc26584: 3c 80 02 00 lis r4,512
rtems_rfs_unlink (rtems_rfs_file_system* fs,
rtems_rfs_ino parent,
rtems_rfs_ino target,
uint32_t doff,
rtems_rfs_unlink_dir dir_mode)
{
ffc26588: 93 e1 00 74 stw r31,116(r1)
ffc2658c: 7c 7f 1b 78 mr r31,r3
rtems_rfs_inode_handle target_inode;
uint16_t links;
bool dir;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
ffc26590: 38 60 00 00 li r3,0
rtems_rfs_unlink (rtems_rfs_file_system* fs,
rtems_rfs_ino parent,
rtems_rfs_ino target,
uint32_t doff,
rtems_rfs_unlink_dir dir_mode)
{
ffc26594: 93 61 00 64 stw r27,100(r1)
ffc26598: 7c fb 3b 78 mr r27,r7
ffc2659c: 93 81 00 68 stw r28,104(r1)
ffc265a0: 7c dc 33 78 mr r28,r6
ffc265a4: 93 c1 00 70 stw r30,112(r1)
ffc265a8: 7c be 2b 78 mr r30,r5
ffc265ac: 90 01 00 7c stw r0,124(r1)
ffc265b0: 93 41 00 60 stw r26,96(r1)
ffc265b4: 91 81 00 5c stw r12,92(r1)
rtems_rfs_inode_handle target_inode;
uint16_t links;
bool dir;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
ffc265b8: 4b ff 13 b1 bl ffc17968 <rtems_rfs_trace>
ffc265bc: 2f 83 00 00 cmpwi cr7,r3,0
ffc265c0: 40 9e 01 60 bne- cr7,ffc26720 <rtems_rfs_unlink+0x1b0> <== NEVER TAKEN
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
ffc265c4: 7f e3 fb 78 mr r3,r31
ffc265c8: 7f c4 f3 78 mr r4,r30
ffc265cc: 38 a1 00 08 addi r5,r1,8
ffc265d0: 38 c0 00 01 li r6,1
ffc265d4: 4b fe da 05 bl ffc13fd8 <rtems_rfs_inode_open>
if (rc)
ffc265d8: 7c 7a 1b 79 mr. r26,r3
ffc265dc: 40 82 00 50 bne- ffc2662c <rtems_rfs_unlink+0xbc> <== NEVER TAKEN
/*
* If a directory process the unlink mode.
*/
dir = RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&target_inode));
ffc265e0: 81 21 00 14 lwz r9,20(r1)
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
ffc265e4: 88 09 00 02 lbz r0,2(r9)
ffc265e8: 54 00 44 26 rlwinm r0,r0,8,16,19
ffc265ec: 68 00 40 00 xori r0,r0,16384
ffc265f0: 7c 00 00 34 cntlzw r0,r0
ffc265f4: 54 00 d9 7e rlwinm r0,r0,27,5,31
if (dir)
ffc265f8: 2e 00 00 00 cmpwi cr4,r0,0
ffc265fc: 41 92 00 6c beq- cr4,ffc26668 <rtems_rfs_unlink+0xf8> <== ALWAYS TAKEN
{
switch (dir_mode)
ffc26600: 2f 9b 00 00 cmpwi cr7,r27,0 <== NOT EXECUTED
ffc26604: 40 9e 00 5c bne- cr7,ffc26660 <rtems_rfs_unlink+0xf0> <== NOT EXECUTED
{
case rtems_rfs_unlink_dir_denied:
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
ffc26608: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc2660c: 3c 80 02 00 lis r4,512 <== NOT EXECUTED
ffc26610: 4b ff 13 59 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc26614: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc26618: 40 9e 01 e4 bne- cr7,ffc267fc <rtems_rfs_unlink+0x28c> <== NOT EXECUTED
printf ("rtems-rfs: link is a directory\n");
rtems_rfs_inode_close (fs, &target_inode);
ffc2661c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc26620: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc26624: 4b fe dc 15 bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
return EISDIR;
ffc26628: 3b 40 00 15 li r26,21 <== NOT EXECUTED
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
rc, strerror (rc));
return rc;
}
ffc2662c: 80 01 00 7c lwz r0,124(r1)
ffc26630: 7f 43 d3 78 mr r3,r26
ffc26634: 81 81 00 5c lwz r12,92(r1)
ffc26638: 7c 08 03 a6 mtlr r0
ffc2663c: 83 41 00 60 lwz r26,96(r1)
ffc26640: 83 61 00 64 lwz r27,100(r1)
ffc26644: 7d 80 81 20 mtcrf 8,r12
ffc26648: 83 81 00 68 lwz r28,104(r1)
ffc2664c: 83 a1 00 6c lwz r29,108(r1)
ffc26650: 83 c1 00 70 lwz r30,112(r1)
ffc26654: 83 e1 00 74 lwz r31,116(r1)
ffc26658: 38 21 00 78 addi r1,r1,120
ffc2665c: 4e 80 00 20 blr
*/
dir = RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&target_inode));
if (dir)
{
switch (dir_mode)
ffc26660: 2f 9b 00 01 cmpwi cr7,r27,1 <== NOT EXECUTED
ffc26664: 41 9e 01 4c beq- cr7,ffc267b0 <rtems_rfs_unlink+0x240> <== NOT EXECUTED
default:
break;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
ffc26668: 7f e3 fb 78 mr r3,r31
ffc2666c: 7f a4 eb 78 mr r4,r29
ffc26670: 38 a1 00 30 addi r5,r1,48
ffc26674: 38 c0 00 01 li r6,1
ffc26678: 4b fe d9 61 bl ffc13fd8 <rtems_rfs_inode_open>
if (rc)
ffc2667c: 7c 7a 1b 79 mr. r26,r3
ffc26680: 40 82 00 bc bne- ffc2673c <rtems_rfs_unlink+0x1cc> <== NEVER TAKEN
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_del_entry (fs, &parent_inode, target, doff);
ffc26684: 7f e3 fb 78 mr r3,r31
ffc26688: 38 81 00 30 addi r4,r1,48
ffc2668c: 7f c5 f3 78 mr r5,r30
ffc26690: 7f 86 e3 78 mr r6,r28
ffc26694: 4b ff d4 e5 bl ffc23b78 <rtems_rfs_dir_del_entry>
if (rc > 0)
ffc26698: 7c 7a 1b 79 mr. r26,r3
ffc2669c: 40 81 01 70 ble- ffc2680c <rtems_rfs_unlink+0x29c> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
ffc266a0: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc266a4: 3c 80 02 00 lis r4,512 <== NOT EXECUTED
ffc266a8: 4b ff 12 c1 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc266ac: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc266b0: 41 be 00 24 beq+ cr7,ffc266d4 <rtems_rfs_unlink+0x164> <== NOT EXECUTED
printf ("rtems-rfs: unlink: dir-del failed: %d: %s\n",
ffc266b4: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc266b8: 48 00 53 f9 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc266bc: 7f 44 d3 78 mr r4,r26 <== NOT EXECUTED
ffc266c0: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc266c4: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc266c8: 38 63 da f4 addi r3,r3,-9484 <== NOT EXECUTED
ffc266cc: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc266d0: 48 00 46 75 bl ffc2ad44 <printf> <== NOT EXECUTED
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",
rc, strerror (rc));
rtems_rfs_inode_close (fs, &parent_inode);
ffc266d4: 38 81 00 30 addi r4,r1,48 <== NOT EXECUTED
ffc266d8: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc266dc: 4b fe db 5d bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
ffc266e0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc266e4: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc266e8: 4b fe db 51 bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
rc, strerror (rc));
return rc;
}
ffc266ec: 80 01 00 7c lwz r0,124(r1) <== NOT EXECUTED
ffc266f0: 81 81 00 5c lwz r12,92(r1) <== NOT EXECUTED
ffc266f4: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc266f8: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc266fc: 83 41 00 60 lwz r26,96(r1) <== NOT EXECUTED
ffc26700: 83 61 00 64 lwz r27,100(r1) <== NOT EXECUTED
ffc26704: 7d 80 81 20 mtcrf 8,r12 <== NOT EXECUTED
ffc26708: 83 81 00 68 lwz r28,104(r1) <== NOT EXECUTED
ffc2670c: 83 a1 00 6c lwz r29,108(r1) <== NOT EXECUTED
ffc26710: 83 c1 00 70 lwz r30,112(r1) <== NOT EXECUTED
ffc26714: 83 e1 00 74 lwz r31,116(r1) <== NOT EXECUTED
ffc26718: 38 21 00 78 addi r1,r1,120 <== NOT EXECUTED
ffc2671c: 4e 80 00 20 blr <== NOT EXECUTED
uint16_t links;
bool dir;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
ffc26720: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc26724: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc26728: 7f c5 f3 78 mr r5,r30 <== NOT EXECUTED
ffc2672c: 38 63 da 5c addi r3,r3,-9636 <== NOT EXECUTED
ffc26730: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc26734: 48 00 46 11 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc26738: 4b ff fe 8c b ffc265c4 <rtems_rfs_unlink+0x54> <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
if (rc)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
ffc2673c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc26740: 3c 80 02 00 lis r4,512 <== NOT EXECUTED
ffc26744: 4b ff 12 25 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc26748: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc2674c: 41 be 00 24 beq+ cr7,ffc26770 <rtems_rfs_unlink+0x200> <== NOT EXECUTED
printf ("rtems-rfs: link: inode-open failed: %d: %s\n",
ffc26750: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc26754: 48 00 53 5d bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc26758: 7f 44 d3 78 mr r4,r26 <== NOT EXECUTED
ffc2675c: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc26760: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc26764: 38 63 da c8 addi r3,r3,-9528 <== NOT EXECUTED
ffc26768: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc2676c: 48 00 45 d9 bl ffc2ad44 <printf> <== NOT EXECUTED
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n",
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
ffc26770: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc26774: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc26778: 4b fe da c1 bl ffc14238 <rtems_rfs_inode_close> <== NOT EXECUTED
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
rc, strerror (rc));
return rc;
}
ffc2677c: 80 01 00 7c lwz r0,124(r1) <== NOT EXECUTED
ffc26780: 81 81 00 5c lwz r12,92(r1) <== NOT EXECUTED
ffc26784: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc26788: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc2678c: 83 41 00 60 lwz r26,96(r1) <== NOT EXECUTED
ffc26790: 83 61 00 64 lwz r27,100(r1) <== NOT EXECUTED
ffc26794: 7d 80 81 20 mtcrf 8,r12 <== NOT EXECUTED
ffc26798: 83 81 00 68 lwz r28,104(r1) <== NOT EXECUTED
ffc2679c: 83 a1 00 6c lwz r29,108(r1) <== NOT EXECUTED
ffc267a0: 83 c1 00 70 lwz r30,112(r1) <== NOT EXECUTED
ffc267a4: 83 e1 00 74 lwz r31,116(r1) <== NOT EXECUTED
ffc267a8: 38 21 00 78 addi r1,r1,120 <== NOT EXECUTED
ffc267ac: 4e 80 00 20 blr <== NOT EXECUTED
printf ("rtems-rfs: link is a directory\n");
rtems_rfs_inode_close (fs, &target_inode);
return EISDIR;
case rtems_rfs_unlink_dir_if_empty:
rc = rtems_rfs_dir_empty (fs, &target_inode);
ffc267b0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc267b4: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc267b8: 4b ff dc bd bl ffc24474 <rtems_rfs_dir_empty> <== NOT EXECUTED
if (rc > 0)
ffc267bc: 7c 7a 1b 79 mr. r26,r3 <== NOT EXECUTED
ffc267c0: 40 a1 fe a8 ble- ffc26668 <rtems_rfs_unlink+0xf8> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
ffc267c4: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc267c8: 3c 80 02 00 lis r4,512 <== NOT EXECUTED
ffc267cc: 4b ff 11 9d bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc267d0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc267d4: 41 9e ff 9c beq+ cr7,ffc26770 <rtems_rfs_unlink+0x200> <== NOT EXECUTED
printf ("rtems-rfs: dir-empty: %d: %s\n", rc, strerror (rc));
ffc267d8: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc267dc: 48 00 52 d5 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc267e0: 7f 44 d3 78 mr r4,r26 <== NOT EXECUTED
ffc267e4: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc267e8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc267ec: 38 63 da a8 addi r3,r3,-9560 <== NOT EXECUTED
ffc267f0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc267f4: 48 00 45 51 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc267f8: 4b ff ff 78 b ffc26770 <rtems_rfs_unlink+0x200> <== NOT EXECUTED
{
switch (dir_mode)
{
case rtems_rfs_unlink_dir_denied:
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link is a directory\n");
ffc267fc: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc26800: 38 63 da 88 addi r3,r3,-9592 <== NOT EXECUTED
ffc26804: 48 00 46 f5 bl ffc2aef8 <puts> <== NOT EXECUTED
ffc26808: 4b ff fe 14 b ffc2661c <rtems_rfs_unlink+0xac> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
links = rtems_rfs_inode_get_links (&target_inode);
ffc2680c: 81 21 00 14 lwz r9,20(r1)
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
ffc26810: 8b a9 00 00 lbz r29,0(r9)
ffc26814: 88 09 00 01 lbz r0,1(r9)
ffc26818: 57 bd 40 2e rlwinm r29,r29,8,0,23
ffc2681c: 7f bd 03 78 or r29,r29,r0
if (links == 0xffff)
ffc26820: 6f a0 ff ff xoris r0,r29,65535
ffc26824: 2f 80 ff ff cmpwi cr7,r0,-1
ffc26828: 41 9e 00 b0 beq- cr7,ffc268d8 <rtems_rfs_unlink+0x368> <== NEVER TAKEN
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
ffc2682c: 38 60 00 00 li r3,0
ffc26830: 3c 80 02 00 lis r4,512
ffc26834: 4b ff 11 35 bl ffc17968 <rtems_rfs_trace>
ffc26838: 2f 83 00 00 cmpwi cr7,r3,0
ffc2683c: 40 9e 00 80 bne- cr7,ffc268bc <rtems_rfs_unlink+0x34c> <== NEVER TAKEN
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
if (links > 1)
ffc26840: 2b 9d 00 01 cmplwi cr7,r29,1
ffc26844: 40 9d 00 e8 ble- cr7,ffc2692c <rtems_rfs_unlink+0x3bc>
{
links--;
ffc26848: 3b bd ff ff addi r29,r29,-1
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
ffc2684c: 81 21 00 14 lwz r9,20(r1)
ffc26850: 57 bd 04 3e clrlwi r29,r29,16
ffc26854: 57 a0 c2 3e rlwinm r0,r29,24,8,31
ffc26858: 98 09 00 00 stb r0,0(r9)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc2685c: 38 00 00 01 li r0,1
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
ffc26860: 81 21 00 14 lwz r9,20(r1)
ffc26864: 9b a9 00 01 stb r29,1(r9)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc26868: 98 01 00 18 stb r0,24(r1)
links--;
rtems_rfs_inode_set_links (&parent_inode, links);
}
}
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
ffc2686c: 38 61 00 30 addi r3,r1,48
ffc26870: 38 80 00 01 li r4,1
ffc26874: 38 a0 00 01 li r5,1
ffc26878: 4b fe db a5 bl ffc1441c <rtems_rfs_inode_time_stamp_now>
if (rc > 0)
ffc2687c: 7c 7a 1b 79 mr. r26,r3
ffc26880: 40 81 00 60 ble- ffc268e0 <rtems_rfs_unlink+0x370> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
ffc26884: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc26888: 3c 80 02 00 lis r4,512 <== NOT EXECUTED
ffc2688c: 4b ff 10 dd bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc26890: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc26894: 41 9e fe 40 beq+ cr7,ffc266d4 <rtems_rfs_unlink+0x164> <== NOT EXECUTED
printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",
ffc26898: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc2689c: 48 00 52 15 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc268a0: 7f 44 d3 78 mr r4,r26 <== NOT EXECUTED
ffc268a4: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc268a8: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc268ac: 38 63 db 78 addi r3,r3,-9352 <== NOT EXECUTED
ffc268b0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc268b4: 48 00 44 91 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc268b8: 4b ff fe 1c b ffc266d4 <rtems_rfs_unlink+0x164> <== NOT EXECUTED
}
links = rtems_rfs_inode_get_links (&target_inode);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
ffc268bc: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc268c0: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc268c4: 7f a5 eb 78 mr r5,r29 <== NOT EXECUTED
ffc268c8: 38 63 db 20 addi r3,r3,-9440 <== NOT EXECUTED
ffc268cc: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc268d0: 48 00 44 75 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc268d4: 4b ff ff 6c b ffc26840 <rtems_rfs_unlink+0x2d0> <== NOT EXECUTED
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
if (links == 0xffff)
links = 0;
ffc268d8: 3b a0 00 00 li r29,0 <== NOT EXECUTED
ffc268dc: 4b ff ff 50 b ffc2682c <rtems_rfs_unlink+0x2bc> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
ffc268e0: 7f e3 fb 78 mr r3,r31
ffc268e4: 38 81 00 30 addi r4,r1,48
ffc268e8: 4b fe d9 51 bl ffc14238 <rtems_rfs_inode_close>
if (rc > 0)
ffc268ec: 7c 7a 1b 79 mr. r26,r3
ffc268f0: 40 81 00 88 ble- ffc26978 <rtems_rfs_unlink+0x408> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
ffc268f4: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc268f8: 3c 80 02 00 lis r4,512 <== NOT EXECUTED
ffc268fc: 4b ff 10 6d bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc26900: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc26904: 41 9e fe 6c beq+ cr7,ffc26770 <rtems_rfs_unlink+0x200> <== NOT EXECUTED
printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n",
ffc26908: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc2690c: 48 00 51 a5 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc26910: 7f 44 d3 78 mr r4,r26 <== NOT EXECUTED
ffc26914: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc26918: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc2691c: 38 63 db ac addi r3,r3,-9300 <== NOT EXECUTED
ffc26920: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc26924: 48 00 44 21 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc26928: 4b ff fe 48 b ffc26770 <rtems_rfs_unlink+0x200> <== NOT EXECUTED
else
{
/*
* Erasing the inode releases all blocks attached to it.
*/
rc = rtems_rfs_inode_delete (fs, &target_inode);
ffc2692c: 7f e3 fb 78 mr r3,r31
ffc26930: 38 81 00 08 addi r4,r1,8
ffc26934: 4b fe d9 e5 bl ffc14318 <rtems_rfs_inode_delete>
if (rc > 0)
ffc26938: 7c 7a 1b 79 mr. r26,r3
ffc2693c: 40 81 00 88 ble- ffc269c4 <rtems_rfs_unlink+0x454> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
ffc26940: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc26944: 3c 80 02 00 lis r4,512 <== NOT EXECUTED
ffc26948: 4b ff 10 21 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc2694c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc26950: 41 9e fd 84 beq+ cr7,ffc266d4 <rtems_rfs_unlink+0x164> <== NOT EXECUTED
printf ("rtems-rfs: unlink: inode-del failed: %d: %s\n",
ffc26954: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc26958: 48 00 51 59 bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc2695c: 7f 44 d3 78 mr r4,r26 <== NOT EXECUTED
ffc26960: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc26964: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc26968: 38 63 db 48 addi r3,r3,-9400 <== NOT EXECUTED
ffc2696c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc26970: 48 00 43 d5 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc26974: 4b ff fd 60 b ffc266d4 <rtems_rfs_unlink+0x164> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
ffc26978: 7f e3 fb 78 mr r3,r31
ffc2697c: 38 81 00 08 addi r4,r1,8
ffc26980: 4b fe d8 b9 bl ffc14238 <rtems_rfs_inode_close>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
ffc26984: 7c 7a 1b 79 mr. r26,r3
ffc26988: 40 a1 fc a4 ble- ffc2662c <rtems_rfs_unlink+0xbc> <== ALWAYS TAKEN
ffc2698c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc26990: 3c 80 02 00 lis r4,512 <== NOT EXECUTED
ffc26994: 4b ff 0f d5 bl ffc17968 <rtems_rfs_trace> <== NOT EXECUTED
ffc26998: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc2699c: 41 9e fc 90 beq+ cr7,ffc2662c <rtems_rfs_unlink+0xbc> <== NOT EXECUTED
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
ffc269a0: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc269a4: 48 00 51 0d bl ffc2bab0 <strerror> <== NOT EXECUTED
ffc269a8: 7f 44 d3 78 mr r4,r26 <== NOT EXECUTED
ffc269ac: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc269b0: 3c 60 ff c4 lis r3,-60 <== NOT EXECUTED
ffc269b4: 38 63 db e0 addi r3,r3,-9248 <== NOT EXECUTED
ffc269b8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc269bc: 48 00 43 89 bl ffc2ad44 <printf> <== NOT EXECUTED
ffc269c0: 4b ff fc 6c b ffc2662c <rtems_rfs_unlink+0xbc> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
if (dir)
ffc269c4: 41 b2 fe a8 beq- cr4,ffc2686c <rtems_rfs_unlink+0x2fc> <== ALWAYS TAKEN
{
links = rtems_rfs_inode_get_links (&parent_inode);
ffc269c8: 81 61 00 3c lwz r11,60(r1) <== NOT EXECUTED
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
ffc269cc: 89 2b 00 00 lbz r9,0(r11) <== NOT EXECUTED
ffc269d0: 88 0b 00 01 lbz r0,1(r11) <== NOT EXECUTED
ffc269d4: 55 29 40 2e rlwinm r9,r9,8,0,23 <== NOT EXECUTED
ffc269d8: 7d 29 03 78 or r9,r9,r0 <== NOT EXECUTED
if (links == 0xffff)
ffc269dc: 6d 20 ff ff xoris r0,r9,65535 <== NOT EXECUTED
ffc269e0: 2f 80 ff ff cmpwi cr7,r0,-1 <== NOT EXECUTED
ffc269e4: 41 9e 00 30 beq- cr7,ffc26a14 <rtems_rfs_unlink+0x4a4> <== NOT EXECUTED
if (links > 1)
ffc269e8: 2b 89 00 01 cmplwi cr7,r9,1 <== NOT EXECUTED
ffc269ec: 40 9d 00 0c ble- cr7,ffc269f8 <rtems_rfs_unlink+0x488> <== NOT EXECUTED
links--;
ffc269f0: 39 29 ff ff addi r9,r9,-1 <== NOT EXECUTED
ffc269f4: 55 29 04 3e clrlwi r9,r9,16 <== NOT EXECUTED
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
ffc269f8: 55 20 c2 3e rlwinm r0,r9,24,8,31 <== NOT EXECUTED
ffc269fc: 98 0b 00 00 stb r0,0(r11) <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc26a00: 38 00 00 01 li r0,1 <== NOT EXECUTED
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
ffc26a04: 81 61 00 3c lwz r11,60(r1) <== NOT EXECUTED
ffc26a08: 99 2b 00 01 stb r9,1(r11) <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc26a0c: 98 01 00 40 stb r0,64(r1) <== NOT EXECUTED
ffc26a10: 4b ff fe 5c b ffc2686c <rtems_rfs_unlink+0x2fc> <== NOT EXECUTED
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
if (links == 0xffff)
links = 0;
ffc26a14: 39 20 00 00 li r9,0 <== NOT EXECUTED
ffc26a18: 4b ff ff e0 b ffc269f8 <rtems_rfs_unlink+0x488> <== NOT EXECUTED
ffc1ae38 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
ffc1ae38: 94 21 ff e0 stwu r1,-32(r1)
ffc1ae3c: 7c 08 02 a6 mflr r0
ffc1ae40: 93 e1 00 1c stw r31,28(r1)
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
ffc1ae44: 7c 9f 23 79 mr. r31,r4
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
ffc1ae48: 90 01 00 24 stw r0,36(r1)
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
ffc1ae4c: 38 00 00 0a li r0,10
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
ffc1ae50: 40 82 00 1c bne- ffc1ae6c <rtems_signal_send+0x34>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
ffc1ae54: 7c 03 03 78 mr r3,r0
ffc1ae58: 80 01 00 24 lwz r0,36(r1)
ffc1ae5c: 83 e1 00 1c lwz r31,28(r1)
ffc1ae60: 38 21 00 20 addi r1,r1,32
ffc1ae64: 7c 08 03 a6 mtlr r0
ffc1ae68: 4e 80 00 20 blr
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
ffc1ae6c: 38 81 00 08 addi r4,r1,8
ffc1ae70: 48 00 5b 6d bl ffc209dc <_Thread_Get>
switch ( location ) {
ffc1ae74: 80 01 00 08 lwz r0,8(r1)
ffc1ae78: 2f 80 00 00 cmpwi cr7,r0,0
ffc1ae7c: 40 9e 00 6c bne- cr7,ffc1aee8 <rtems_signal_send+0xb0>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
ffc1ae80: 81 23 01 30 lwz r9,304(r3)
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
ffc1ae84: 80 09 00 0c lwz r0,12(r9)
ffc1ae88: 2f 80 00 00 cmpwi cr7,r0,0
ffc1ae8c: 41 9e 00 78 beq- cr7,ffc1af04 <rtems_signal_send+0xcc>
if ( asr->is_enabled ) {
ffc1ae90: 88 09 00 08 lbz r0,8(r9)
ffc1ae94: 2f 80 00 00 cmpwi cr7,r0,0
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc1ae98: 7c 00 00 a6 mfmsr r0
ffc1ae9c: 7d 70 42 a6 mfsprg r11,0
ffc1aea0: 7c 0b 58 78 andc r11,r0,r11
ffc1aea4: 7d 60 01 24 mtmsr r11
ffc1aea8: 41 9e 00 68 beq- cr7,ffc1af10 <rtems_signal_send+0xd8>
)
{
ISR_Level _level;
_ISR_Disable( _level );
*signal_set |= signals;
ffc1aeac: 81 69 00 14 lwz r11,20(r9)
ffc1aeb0: 7d 7f fb 78 or r31,r11,r31
ffc1aeb4: 93 e9 00 14 stw r31,20(r9)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc1aeb8: 7c 00 01 24 mtmsr r0
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
ffc1aebc: 3d 20 00 00 lis r9,0
ffc1aec0: 39 29 75 44 addi r9,r9,30020
ffc1aec4: 80 09 00 08 lwz r0,8(r9)
ffc1aec8: 2f 80 00 00 cmpwi cr7,r0,0
ffc1aecc: 41 9e 00 10 beq- cr7,ffc1aedc <rtems_signal_send+0xa4>
ffc1aed0: 80 09 00 0c lwz r0,12(r9)
ffc1aed4: 7f 83 00 00 cmpw cr7,r3,r0
ffc1aed8: 41 9e 00 4c beq- cr7,ffc1af24 <rtems_signal_send+0xec> <== ALWAYS TAKEN
_Thread_Dispatch_necessary = true;
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
ffc1aedc: 48 00 5a c5 bl ffc209a0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
ffc1aee0: 38 00 00 00 li r0,0
ffc1aee4: 4b ff ff 70 b ffc1ae54 <rtems_signal_send+0x1c>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
ffc1aee8: 38 00 00 04 li r0,4
}
ffc1aeec: 83 e1 00 1c lwz r31,28(r1)
ffc1aef0: 7c 03 03 78 mr r3,r0
ffc1aef4: 80 01 00 24 lwz r0,36(r1)
ffc1aef8: 38 21 00 20 addi r1,r1,32
ffc1aefc: 7c 08 03 a6 mtlr r0
ffc1af00: 4e 80 00 20 blr
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
ffc1af04: 48 00 5a 9d bl ffc209a0 <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
ffc1af08: 38 00 00 0b li r0,11
ffc1af0c: 4b ff ff 48 b ffc1ae54 <rtems_signal_send+0x1c>
ffc1af10: 81 69 00 18 lwz r11,24(r9)
ffc1af14: 7d 7f fb 78 or r31,r11,r31
ffc1af18: 93 e9 00 18 stw r31,24(r9)
ffc1af1c: 7c 00 01 24 mtmsr r0
ffc1af20: 4b ff ff bc b ffc1aedc <rtems_signal_send+0xa4>
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
if ( asr->is_enabled ) {
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
ffc1af24: 38 00 00 01 li r0,1
ffc1af28: 98 09 00 18 stb r0,24(r9)
ffc1af2c: 4b ff ff b0 b ffc1aedc <rtems_signal_send+0xa4>
ffc049f8 <rtems_stack_checker_begin_extension>:
* rtems_stack_checker_Begin_extension
*/
void rtems_stack_checker_begin_extension(
Thread_Control *the_thread
)
{
ffc049f8: 7c 08 02 a6 mflr r0
ffc049fc: 94 21 ff f8 stwu r1,-8(r1)
ffc04a00: 90 01 00 0c stw r0,12(r1)
Stack_check_Control *the_pattern;
if ( the_thread->Object.id == 0 ) /* skip system tasks */
ffc04a04: 80 03 00 08 lwz r0,8(r3)
ffc04a08: 2f 80 00 00 cmpwi cr7,r0,0
ffc04a0c: 41 9e 00 1c beq- cr7,ffc04a28 <rtems_stack_checker_begin_extension+0x30><== NEVER TAKEN
return;
the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack);
*the_pattern = Stack_check_Pattern;
ffc04a10: 80 63 00 bc lwz r3,188(r3)
ffc04a14: 3c 80 00 00 lis r4,0
ffc04a18: 38 84 2b 68 addi r4,r4,11112
ffc04a1c: 38 63 00 08 addi r3,r3,8
ffc04a20: 38 a0 00 80 li r5,128
ffc04a24: 48 01 2e d1 bl ffc178f4 <memcpy>
}
ffc04a28: 80 01 00 0c lwz r0,12(r1)
ffc04a2c: 38 21 00 08 addi r1,r1,8
ffc04a30: 7c 08 03 a6 mtlr r0
ffc04a34: 4e 80 00 20 blr
ffc04974 <rtems_stack_checker_create_extension>:
*/
bool rtems_stack_checker_create_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *the_thread
)
{
ffc04974: 7c 08 02 a6 mflr r0
ffc04978: 94 21 ff f8 stwu r1,-8(r1)
static uint32_t pattern[ 4 ] = {
0xFEEDF00D, 0x0BAD0D06, /* FEED FOOD to BAD DOG */
0xDEADF00D, 0x600D0D06 /* DEAD FOOD but GOOD DOG */
};
if ( Stack_check_Initialized )
ffc0497c: 3d 20 00 00 lis r9,0
*/
bool rtems_stack_checker_create_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *the_thread
)
{
ffc04980: 90 01 00 0c stw r0,12(r1)
static uint32_t pattern[ 4 ] = {
0xFEEDF00D, 0x0BAD0D06, /* FEED FOOD to BAD DOG */
0xDEADF00D, 0x600D0D06 /* DEAD FOOD but GOOD DOG */
};
if ( Stack_check_Initialized )
ffc04984: 39 29 28 f4 addi r9,r9,10484
ffc04988: 80 09 00 08 lwz r0,8(r9)
ffc0498c: 2f 80 00 00 cmpwi cr7,r0,0
ffc04990: 40 9e 00 3c bne- cr7,ffc049cc <rtems_stack_checker_create_extension+0x58>
ffc04994: 38 00 00 20 li r0,32
ffc04998: 7c 09 03 a6 mtctr r0
ffc0499c: 3d 40 00 00 lis r10,0
ffc049a0: 3d 00 ff c2 lis r8,-62
ffc049a4: 39 4a 2b 64 addi r10,r10,11108
}
/*
* rtems_stack_checker_create_extension
*/
bool rtems_stack_checker_create_extension(
ffc049a8: 39 60 00 00 li r11,0
ffc049ac: 39 08 dc 0c addi r8,r8,-9204
/*
* Dope the pattern and fill areas
*/
p = Stack_check_Pattern.pattern;
for ( i = 0; i < PATTERN_SIZE_WORDS; i++ ) {
p[i] = pattern[ i%4 ];
ffc049b0: 55 60 17 3a rlwinm r0,r11,2,28,29
ffc049b4: 7c 08 00 2e lwzx r0,r8,r0
/*
* Dope the pattern and fill areas
*/
p = Stack_check_Pattern.pattern;
for ( i = 0; i < PATTERN_SIZE_WORDS; i++ ) {
ffc049b8: 39 6b 00 01 addi r11,r11,1
p[i] = pattern[ i%4 ];
ffc049bc: 94 0a 00 04 stwu r0,4(r10)
/*
* Dope the pattern and fill areas
*/
p = Stack_check_Pattern.pattern;
for ( i = 0; i < PATTERN_SIZE_WORDS; i++ ) {
ffc049c0: 42 00 ff f0 bdnz+ ffc049b0 <rtems_stack_checker_create_extension+0x3c>
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
}
#endif
Stack_check_Initialized = 1;
ffc049c4: 38 00 00 01 li r0,1
ffc049c8: 90 09 00 08 stw r0,8(r9)
Thread_Control *the_thread
)
{
Stack_check_Initialize();
if (the_thread)
ffc049cc: 2f 84 00 00 cmpwi cr7,r4,0
ffc049d0: 41 9e 00 14 beq- cr7,ffc049e4 <rtems_stack_checker_create_extension+0x70><== NEVER TAKEN
Stack_check_Dope_stack(&the_thread->Start.Initial_stack);
ffc049d4: 80 64 00 bc lwz r3,188(r4)
ffc049d8: 80 a4 00 b8 lwz r5,184(r4)
ffc049dc: 38 80 00 a5 li r4,165
ffc049e0: 48 01 2f f9 bl ffc179d8 <memset>
return true;
}
ffc049e4: 80 01 00 0c lwz r0,12(r1)
ffc049e8: 38 60 00 01 li r3,1
ffc049ec: 38 21 00 08 addi r1,r1,8
ffc049f0: 7c 08 03 a6 mtlr r0
ffc049f4: 4e 80 00 20 blr
ffc04ba4 <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
ffc04ba4: 94 21 ff e8 stwu r1,-24(r1)
ffc04ba8: 7c 08 02 a6 mflr r0
ffc04bac: 93 a1 00 0c stw r29,12(r1)
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
ffc04bb0: 3f a0 00 00 lis r29,0
ffc04bb4: 3b bd 32 44 addi r29,r29,12868
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
ffc04bb8: 90 01 00 1c stw r0,28(r1)
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
ffc04bbc: 81 3d 00 0c lwz r9,12(r29)
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
ffc04bc0: 93 e1 00 14 stw r31,20(r1)
ffc04bc4: 7c 3f 0b 78 mr r31,r1
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
ffc04bc8: 80 69 00 bc lwz r3,188(r9)
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
ffc04bcc: 93 c1 00 10 stw r30,16(r1)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
return false;
ffc04bd0: 3b c0 00 00 li r30,0
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
ffc04bd4: 7f 9f 18 40 cmplw cr7,r31,r3
ffc04bd8: 41 9c 00 18 blt- cr7,ffc04bf0 <rtems_stack_checker_is_blown+0x4c><== NEVER TAKEN
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
ffc04bdc: 83 c9 00 b8 lwz r30,184(r9)
ffc04be0: 7f c3 f2 14 add r30,r3,r30
}
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
ffc04be4: 7f df f0 10 subfc r30,r31,r30
ffc04be8: 3b c0 00 00 li r30,0
ffc04bec: 7f de f1 14 adde r30,r30,r30
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
ffc04bf0: 3d 20 00 00 lis r9,0
ffc04bf4: 80 09 28 fc lwz r0,10492(r9)
*/
bool rtems_stack_checker_is_blown( void )
{
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
bool sp_ok;
bool pattern_ok = true;
ffc04bf8: 38 80 00 01 li r4,1
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
ffc04bfc: 2f 80 00 00 cmpwi cr7,r0,0
ffc04c00: 41 9e 00 20 beq- cr7,ffc04c20 <rtems_stack_checker_is_blown+0x7c><== NEVER TAKEN
pattern_ok = (!memcmp(
ffc04c04: 3c 80 00 00 lis r4,0
ffc04c08: 38 84 2b 68 addi r4,r4,11112
ffc04c0c: 38 63 00 08 addi r3,r3,8
ffc04c10: 38 a0 00 80 li r5,128
ffc04c14: 48 01 2c 3d bl ffc17850 <memcmp>
ffc04c18: 7c 64 00 34 cntlzw r4,r3
ffc04c1c: 54 84 d9 7e rlwinm r4,r4,27,5,31
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
ffc04c20: 2f 9e 00 00 cmpwi cr7,r30,0
ffc04c24: 41 9e 00 30 beq- cr7,ffc04c54 <rtems_stack_checker_is_blown+0xb0><== NEVER TAKEN
ffc04c28: 2f 84 00 00 cmpwi cr7,r4,0
ffc04c2c: 41 9e 00 28 beq- cr7,ffc04c54 <rtems_stack_checker_is_blown+0xb0><== NEVER TAKEN
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
ffc04c30: 39 7f 00 18 addi r11,r31,24
ffc04c34: 80 0b 00 04 lwz r0,4(r11)
ffc04c38: 38 60 00 00 li r3,0
ffc04c3c: 83 ab ff f4 lwz r29,-12(r11)
ffc04c40: 7c 08 03 a6 mtlr r0
ffc04c44: 83 cb ff f8 lwz r30,-8(r11)
ffc04c48: 83 eb ff fc lwz r31,-4(r11)
ffc04c4c: 7d 61 5b 78 mr r1,r11
ffc04c50: 4e 80 00 20 blr
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
ffc04c54: 80 7d 00 0c lwz r3,12(r29) <== NOT EXECUTED
ffc04c58: 4b ff fd e1 bl ffc04a38 <Stack_check_report_blown_task><== NOT EXECUTED
ffc04c5c <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
ffc04c5c: 94 21 ff e8 stwu r1,-24(r1)
ffc04c60: 7c 08 02 a6 mflr r0
ffc04c64: 93 e1 00 14 stw r31,20(r1)
if ( !print )
ffc04c68: 7c 9f 23 79 mr. r31,r4
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
ffc04c6c: 93 a1 00 0c stw r29,12(r1)
ffc04c70: 7c 7d 1b 78 mr r29,r3
ffc04c74: 90 01 00 1c stw r0,28(r1)
ffc04c78: 93 81 00 08 stw r28,8(r1)
ffc04c7c: 93 c1 00 10 stw r30,16(r1)
if ( !print )
ffc04c80: 41 82 00 58 beq- ffc04cd8 <rtems_stack_checker_report_usage_with_plugin+0x7c><== NEVER TAKEN
return;
print_context = context;
ffc04c84: 3f c0 00 00 lis r30,0
print_handler = print;
(*print)( context, "Stack usage by thread\n");
ffc04c88: 7f e9 03 a6 mtctr r31
)
{
if ( !print )
return;
print_context = context;
ffc04c8c: 3b 9e 28 f4 addi r28,r30,10484
print_handler = print;
ffc04c90: 93 fe 28 f4 stw r31,10484(r30)
(*print)( context, "Stack usage by thread\n");
ffc04c94: 3c 80 ff c2 lis r4,-62
ffc04c98: 38 84 dd 40 addi r4,r4,-8896
)
{
if ( !print )
return;
print_context = context;
ffc04c9c: 90 7c 00 04 stw r3,4(r28)
print_handler = print;
(*print)( context, "Stack usage by thread\n");
ffc04ca0: 4c c6 31 82 crclr 4*cr1+eq
ffc04ca4: 4e 80 04 21 bctrl
(*print)( context,
ffc04ca8: 3c 80 ff c2 lis r4,-62
ffc04cac: 38 84 dd 58 addi r4,r4,-8872
ffc04cb0: 7f e9 03 a6 mtctr r31
ffc04cb4: 7f a3 eb 78 mr r3,r29
ffc04cb8: 4c c6 31 82 crclr 4*cr1+eq
ffc04cbc: 4e 80 04 21 bctrl
" 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 );
ffc04cc0: 3c 60 ff c0 lis r3,-64
ffc04cc4: 38 63 47 58 addi r3,r3,18264
ffc04cc8: 48 00 91 2d bl ffc0ddf4 <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);
#endif
print_context = NULL;
ffc04ccc: 38 00 00 00 li r0,0
ffc04cd0: 90 1c 00 04 stw r0,4(r28)
print_handler = NULL;
ffc04cd4: 90 1e 28 f4 stw r0,10484(r30)
}
ffc04cd8: 80 01 00 1c lwz r0,28(r1)
ffc04cdc: 83 81 00 08 lwz r28,8(r1)
ffc04ce0: 7c 08 03 a6 mtlr r0
ffc04ce4: 83 a1 00 0c lwz r29,12(r1)
ffc04ce8: 83 c1 00 10 lwz r30,16(r1)
ffc04cec: 83 e1 00 14 lwz r31,20(r1)
ffc04cf0: 38 21 00 18 addi r1,r1,24
ffc04cf4: 4e 80 00 20 blr
ffc04b18 <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
ffc04b18: 94 21 ff f0 stwu r1,-16(r1)
ffc04b1c: 7c 08 02 a6 mflr r0
/*
* 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,
ffc04b20: 3c 80 00 00 lis r4,0
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
ffc04b24: 90 01 00 14 stw r0,20(r1)
/*
* 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,
ffc04b28: 38 84 2b 68 addi r4,r4,11112
ffc04b2c: 38 a0 00 80 li r5,128
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);
ffc04b30: 81 23 00 bc lwz r9,188(r3)
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
ffc04b34: 93 e1 00 0c stw r31,12(r1)
ffc04b38: 7c 3f 0b 78 mr r31,r1
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
ffc04b3c: 7f 9f 48 40 cmplw cr7,r31,r9
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
ffc04b40: 93 c1 00 08 stw r30,8(r1)
ffc04b44: 7c 7e 1b 78 mr r30,r3
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);
ffc04b48: 38 69 00 08 addi r3,r9,8
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
ffc04b4c: 41 9c 00 14 blt- cr7,ffc04b60 <rtems_stack_checker_switch_extension+0x48><== NEVER TAKEN
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
ffc04b50: 80 1e 00 b8 lwz r0,184(r30)
ffc04b54: 7d 29 02 14 add r9,r9,r0
ffc04b58: 7f 9f 48 40 cmplw cr7,r31,r9
ffc04b5c: 40 9d 00 18 ble- cr7,ffc04b74 <rtems_stack_checker_switch_extension+0x5c><== ALWAYS TAKEN
/*
* 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,
ffc04b60: 48 01 2c f1 bl ffc17850 <memcmp> <== NOT EXECUTED
ffc04b64: 7c 64 00 34 cntlzw r4,r3 <== NOT EXECUTED
ffc04b68: 54 84 d9 7e rlwinm r4,r4,27,5,31 <== NOT EXECUTED
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
Stack_check_report_blown_task( running, pattern_ok );
ffc04b6c: 7f c3 f3 78 mr r3,r30
ffc04b70: 4b ff fe c9 bl ffc04a38 <Stack_check_report_blown_task>
/*
* Check for an out of bounds stack pointer or an overwrite
*/
sp_ok = Stack_check_Frame_pointer_in_range( the_stack );
pattern_ok = (!memcmp( pattern,
ffc04b74: 48 01 2c dd bl ffc17850 <memcmp>
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
ffc04b78: 2f 83 00 00 cmpwi cr7,r3,0
ffc04b7c: 40 9e 00 20 bne- cr7,ffc04b9c <rtems_stack_checker_switch_extension+0x84>
Stack_check_report_blown_task( running, pattern_ok );
}
}
ffc04b80: 39 7f 00 10 addi r11,r31,16
ffc04b84: 80 0b 00 04 lwz r0,4(r11)
ffc04b88: 83 cb ff f8 lwz r30,-8(r11)
ffc04b8c: 7c 08 03 a6 mtlr r0
ffc04b90: 83 eb ff fc lwz r31,-4(r11)
ffc04b94: 7d 61 5b 78 mr r1,r11
ffc04b98: 4e 80 00 20 blr
sp_ok = Stack_check_Frame_pointer_in_range( the_stack );
pattern_ok = (!memcmp( pattern,
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
ffc04b9c: 38 80 00 00 li r4,0
ffc04ba0: 4b ff ff cc b ffc04b6c <rtems_stack_checker_switch_extension+0x54>
ffc101c4 <rtems_string_to_double>:
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
ffc101c4: 94 21 ff d0 stwu r1,-48(r1)
ffc101c8: 7c 08 02 a6 mflr r0
ffc101cc: 93 c1 00 20 stw r30,32(r1)
double result;
char *end;
if ( !n )
ffc101d0: 7c 9e 23 79 mr. r30,r4
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
ffc101d4: 93 a1 00 1c stw r29,28(r1)
ffc101d8: 7c bd 2b 78 mr r29,r5
ffc101dc: 93 e1 00 24 stw r31,36(r1)
ffc101e0: 7c 7f 1b 78 mr r31,r3
double result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
ffc101e4: 38 60 00 09 li r3,9
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
ffc101e8: 90 01 00 34 stw r0,52(r1)
ffc101ec: db e1 00 28 stfd f31,40(r1)
ffc101f0: 93 81 00 18 stw r28,24(r1)
double result;
char *end;
if ( !n )
ffc101f4: 41 82 00 60 beq- ffc10254 <rtems_string_to_double+0x90>
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
ffc101f8: 3f 80 ff c2 lis r28,-62
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
ffc101fc: 48 00 3d cd bl ffc13fc8 <__errno>
*n = 0;
ffc10200: c8 1c 1f 48 lfd f0,8008(r28)
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
ffc10204: 38 00 00 00 li r0,0
ffc10208: 90 03 00 00 stw r0,0(r3)
*n = 0;
result = strtod( s, &end );
ffc1020c: 38 81 00 08 addi r4,r1,8
ffc10210: 7f e3 fb 78 mr r3,r31
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
ffc10214: d8 1e 00 00 stfd f0,0(r30)
result = strtod( s, &end );
ffc10218: 48 00 6a e1 bl ffc16cf8 <strtod>
if ( endptr )
ffc1021c: 2f 9d 00 00 cmpwi cr7,r29,0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtod( s, &end );
ffc10220: ff e0 08 90 fmr f31,f1
if ( endptr )
*endptr = end;
ffc10224: 80 01 00 08 lwz r0,8(r1)
errno = 0;
*n = 0;
result = strtod( s, &end );
if ( endptr )
ffc10228: 41 9e 00 08 beq- cr7,ffc10230 <rtems_string_to_double+0x6c>
*endptr = end;
ffc1022c: 90 1d 00 00 stw r0,0(r29)
if ( end == s )
ffc10230: 7f 9f 00 00 cmpw cr7,r31,r0
return RTEMS_NOT_DEFINED;
ffc10234: 38 60 00 0b li r3,11
result = strtod( s, &end );
if ( endptr )
*endptr = end;
if ( end == s )
ffc10238: 41 9e 00 1c beq- cr7,ffc10254 <rtems_string_to_double+0x90>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc1023c: 48 00 3d 8d bl ffc13fc8 <__errno>
ffc10240: 80 03 00 00 lwz r0,0(r3)
ffc10244: 2f 80 00 22 cmpwi cr7,r0,34
ffc10248: 41 9e 00 30 beq- cr7,ffc10278 <rtems_string_to_double+0xb4>
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
*n = result;
ffc1024c: db fe 00 00 stfd f31,0(r30)
return RTEMS_SUCCESSFUL;
ffc10250: 38 60 00 00 li r3,0
}
ffc10254: 80 01 00 34 lwz r0,52(r1)
ffc10258: 83 81 00 18 lwz r28,24(r1)
ffc1025c: 7c 08 03 a6 mtlr r0
ffc10260: 83 a1 00 1c lwz r29,28(r1)
ffc10264: 83 c1 00 20 lwz r30,32(r1)
ffc10268: 83 e1 00 24 lwz r31,36(r1)
ffc1026c: cb e1 00 28 lfd f31,40(r1)
ffc10270: 38 21 00 30 addi r1,r1,48
ffc10274: 4e 80 00 20 blr
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc10278: c8 1c 1f 48 lfd f0,8008(r28)
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
ffc1027c: 38 60 00 0a li r3,10
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc10280: ff 9f 00 00 fcmpu cr7,f31,f0
ffc10284: 41 9e ff d0 beq+ cr7,ffc10254 <rtems_string_to_double+0x90><== NEVER TAKEN
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
ffc10288: 3d 20 ff c2 lis r9,-62
ffc1028c: c8 09 46 a0 lfd f0,18080(r9)
ffc10290: ff 9f 00 00 fcmpu cr7,f31,f0
ffc10294: 41 9d ff c0 bgt+ cr7,ffc10254 <rtems_string_to_double+0x90>
ffc10298: 3d 20 ff c2 lis r9,-62
ffc1029c: c8 09 46 a8 lfd f0,18088(r9)
ffc102a0: ff 9f 00 00 fcmpu cr7,f31,f0
ffc102a4: 41 9c ff b0 blt+ cr7,ffc10254 <rtems_string_to_double+0x90><== ALWAYS TAKEN
ffc102a8: 4b ff ff a4 b ffc1024c <rtems_string_to_double+0x88> <== NOT EXECUTED
ffc102ac <rtems_string_to_float>:
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
ffc102ac: 94 21 ff d0 stwu r1,-48(r1)
ffc102b0: 7c 08 02 a6 mflr r0
ffc102b4: 93 c1 00 20 stw r30,32(r1)
float result;
char *end;
if ( !n )
ffc102b8: 7c 9e 23 79 mr. r30,r4
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
ffc102bc: 93 a1 00 1c stw r29,28(r1)
ffc102c0: 7c bd 2b 78 mr r29,r5
ffc102c4: 93 e1 00 24 stw r31,36(r1)
ffc102c8: 7c 7f 1b 78 mr r31,r3
float result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
ffc102cc: 38 60 00 09 li r3,9
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
ffc102d0: 90 01 00 34 stw r0,52(r1)
ffc102d4: db e1 00 28 stfd f31,40(r1)
float result;
char *end;
if ( !n )
ffc102d8: 41 82 00 5c beq- ffc10334 <rtems_string_to_float+0x88>
return RTEMS_INVALID_ADDRESS;
errno = 0;
ffc102dc: 48 00 3c ed bl ffc13fc8 <__errno>
ffc102e0: 38 00 00 00 li r0,0
ffc102e4: 90 03 00 00 stw r0,0(r3)
*n = 0;
ffc102e8: 38 00 00 00 li r0,0
result = strtof( s, &end );
ffc102ec: 7f e3 fb 78 mr r3,r31
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
ffc102f0: 90 1e 00 00 stw r0,0(r30)
result = strtof( s, &end );
ffc102f4: 38 81 00 08 addi r4,r1,8
ffc102f8: 48 00 6a 19 bl ffc16d10 <strtof>
if ( endptr )
ffc102fc: 2f 9d 00 00 cmpwi cr7,r29,0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtof( s, &end );
ffc10300: ff e0 08 90 fmr f31,f1
if ( endptr )
*endptr = end;
ffc10304: 80 01 00 08 lwz r0,8(r1)
errno = 0;
*n = 0;
result = strtof( s, &end );
if ( endptr )
ffc10308: 41 9e 00 08 beq- cr7,ffc10310 <rtems_string_to_float+0x64>
*endptr = end;
ffc1030c: 90 1d 00 00 stw r0,0(r29)
if ( end == s )
ffc10310: 7f 9f 00 00 cmpw cr7,r31,r0
return RTEMS_NOT_DEFINED;
ffc10314: 38 60 00 0b li r3,11
result = strtof( s, &end );
if ( endptr )
*endptr = end;
if ( end == s )
ffc10318: 41 9e 00 1c beq- cr7,ffc10334 <rtems_string_to_float+0x88>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc1031c: 48 00 3c ad bl ffc13fc8 <__errno>
ffc10320: 80 03 00 00 lwz r0,0(r3)
ffc10324: 2f 80 00 22 cmpwi cr7,r0,34
ffc10328: 41 9e 00 2c beq- cr7,ffc10354 <rtems_string_to_float+0xa8>
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
return RTEMS_INVALID_NUMBER;
*n = result;
ffc1032c: d3 fe 00 00 stfs f31,0(r30)
return RTEMS_SUCCESSFUL;
ffc10330: 38 60 00 00 li r3,0
}
ffc10334: 80 01 00 34 lwz r0,52(r1)
ffc10338: 83 a1 00 1c lwz r29,28(r1)
ffc1033c: 7c 08 03 a6 mtlr r0
ffc10340: 83 c1 00 20 lwz r30,32(r1)
ffc10344: 83 e1 00 24 lwz r31,36(r1)
ffc10348: cb e1 00 28 lfd f31,40(r1)
ffc1034c: 38 21 00 30 addi r1,r1,48
ffc10350: 4e 80 00 20 blr
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc10354: 3d 20 ff c2 lis r9,-62
ffc10358: c0 09 1f 3c lfs f0,7996(r9)
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
return RTEMS_INVALID_NUMBER;
ffc1035c: 38 60 00 0a li r3,10
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc10360: ff 9f 00 00 fcmpu cr7,f31,f0
ffc10364: 41 9e ff d0 beq+ cr7,ffc10334 <rtems_string_to_float+0x88><== NEVER TAKEN
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
ffc10368: 3d 20 ff c2 lis r9,-62
ffc1036c: c0 09 46 b0 lfs f0,18096(r9)
ffc10370: ff 9f 00 00 fcmpu cr7,f31,f0
ffc10374: 41 9d ff c0 bgt+ cr7,ffc10334 <rtems_string_to_float+0x88>
ffc10378: 3d 20 ff c2 lis r9,-62
ffc1037c: c0 09 46 b4 lfs f0,18100(r9)
ffc10380: ff 9f 00 00 fcmpu cr7,f31,f0
ffc10384: 41 9c ff b0 blt+ cr7,ffc10334 <rtems_string_to_float+0x88><== ALWAYS TAKEN
ffc10388: 4b ff ff a4 b ffc1032c <rtems_string_to_float+0x80> <== NOT EXECUTED
ffc1038c <rtems_string_to_int>:
const char *s,
int *n,
char **endptr,
int base
)
{
ffc1038c: 94 21 ff d8 stwu r1,-40(r1)
ffc10390: 7c 08 02 a6 mflr r0
ffc10394: 93 a1 00 1c stw r29,28(r1)
long result;
char *end;
if ( !n )
ffc10398: 7c 9d 23 79 mr. r29,r4
const char *s,
int *n,
char **endptr,
int base
)
{
ffc1039c: 93 81 00 18 stw r28,24(r1)
ffc103a0: 7c dc 33 78 mr r28,r6
ffc103a4: 93 c1 00 20 stw r30,32(r1)
ffc103a8: 7c be 2b 78 mr r30,r5
ffc103ac: 93 e1 00 24 stw r31,36(r1)
ffc103b0: 7c 7f 1b 78 mr r31,r3
long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
ffc103b4: 38 60 00 09 li r3,9
const char *s,
int *n,
char **endptr,
int base
)
{
ffc103b8: 90 01 00 2c stw r0,44(r1)
long result;
char *end;
if ( !n )
ffc103bc: 41 82 00 5c beq- ffc10418 <rtems_string_to_int+0x8c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
ffc103c0: 48 00 3c 09 bl ffc13fc8 <__errno>
ffc103c4: 38 00 00 00 li r0,0
ffc103c8: 90 03 00 00 stw r0,0(r3)
*n = 0;
result = strtol( s, &end, base );
ffc103cc: 7f 85 e3 78 mr r5,r28
ffc103d0: 7f e3 fb 78 mr r3,r31
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
ffc103d4: 90 1d 00 00 stw r0,0(r29)
result = strtol( s, &end, base );
ffc103d8: 38 81 00 08 addi r4,r1,8
ffc103dc: 48 00 6b b5 bl ffc16f90 <strtol>
if ( endptr )
ffc103e0: 2f 9e 00 00 cmpwi cr7,r30,0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtol( s, &end, base );
ffc103e4: 7c 7c 1b 78 mr r28,r3
if ( endptr )
*endptr = end;
ffc103e8: 80 01 00 08 lwz r0,8(r1)
errno = 0;
*n = 0;
result = strtol( s, &end, base );
if ( endptr )
ffc103ec: 41 9e 00 08 beq- cr7,ffc103f4 <rtems_string_to_int+0x68>
*endptr = end;
ffc103f0: 90 1e 00 00 stw r0,0(r30)
if ( end == s )
ffc103f4: 7f 9f 00 00 cmpw cr7,r31,r0
return RTEMS_NOT_DEFINED;
ffc103f8: 38 60 00 0b li r3,11
result = strtol( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
ffc103fc: 41 9e 00 1c beq- cr7,ffc10418 <rtems_string_to_int+0x8c>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc10400: 48 00 3b c9 bl ffc13fc8 <__errno>
ffc10404: 80 03 00 00 lwz r0,0(r3)
ffc10408: 2f 80 00 22 cmpwi cr7,r0,34
ffc1040c: 41 9e 00 2c beq- cr7,ffc10438 <rtems_string_to_int+0xac>
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
ffc10410: 93 9d 00 00 stw r28,0(r29)
return RTEMS_SUCCESSFUL;
ffc10414: 38 60 00 00 li r3,0
}
ffc10418: 80 01 00 2c lwz r0,44(r1)
ffc1041c: 83 81 00 18 lwz r28,24(r1)
ffc10420: 7c 08 03 a6 mtlr r0
ffc10424: 83 a1 00 1c lwz r29,28(r1)
ffc10428: 83 c1 00 20 lwz r30,32(r1)
ffc1042c: 83 e1 00 24 lwz r31,36(r1)
ffc10430: 38 21 00 28 addi r1,r1,40
ffc10434: 4e 80 00 20 blr
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc10438: 2f 9c 00 00 cmpwi cr7,r28,0
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
return RTEMS_INVALID_NUMBER;
ffc1043c: 38 60 00 0a li r3,10
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc10440: 41 9e ff d8 beq+ cr7,ffc10418 <rtems_string_to_int+0x8c><== NEVER TAKEN
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
ffc10444: 6f 80 80 00 xoris r0,r28,32768
ffc10448: 2f 80 ff ff cmpwi cr7,r0,-1
ffc1044c: 41 9e ff cc beq+ cr7,ffc10418 <rtems_string_to_int+0x8c>
ffc10450: 3c 00 80 00 lis r0,-32768
ffc10454: 7f 9c 00 00 cmpw cr7,r28,r0
ffc10458: 40 9e ff b8 bne+ cr7,ffc10410 <rtems_string_to_int+0x84><== NEVER TAKEN
ffc1045c: 4b ff ff bc b ffc10418 <rtems_string_to_int+0x8c>
ffc10568 <rtems_string_to_long>:
const char *s,
long *n,
char **endptr,
int base
)
{
ffc10568: 94 21 ff d8 stwu r1,-40(r1)
ffc1056c: 7c 08 02 a6 mflr r0
ffc10570: 93 a1 00 1c stw r29,28(r1)
long result;
char *end;
if ( !n )
ffc10574: 7c 9d 23 79 mr. r29,r4
const char *s,
long *n,
char **endptr,
int base
)
{
ffc10578: 93 81 00 18 stw r28,24(r1)
ffc1057c: 7c dc 33 78 mr r28,r6
ffc10580: 93 c1 00 20 stw r30,32(r1)
ffc10584: 7c be 2b 78 mr r30,r5
ffc10588: 93 e1 00 24 stw r31,36(r1)
ffc1058c: 7c 7f 1b 78 mr r31,r3
long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
ffc10590: 38 60 00 09 li r3,9
const char *s,
long *n,
char **endptr,
int base
)
{
ffc10594: 90 01 00 2c stw r0,44(r1)
long result;
char *end;
if ( !n )
ffc10598: 41 82 00 5c beq- ffc105f4 <rtems_string_to_long+0x8c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
ffc1059c: 48 00 3a 2d bl ffc13fc8 <__errno>
ffc105a0: 38 00 00 00 li r0,0
ffc105a4: 90 03 00 00 stw r0,0(r3)
*n = 0;
result = strtol( s, &end, base );
ffc105a8: 7f 85 e3 78 mr r5,r28
ffc105ac: 7f e3 fb 78 mr r3,r31
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
ffc105b0: 90 1d 00 00 stw r0,0(r29)
result = strtol( s, &end, base );
ffc105b4: 38 81 00 08 addi r4,r1,8
ffc105b8: 48 00 69 d9 bl ffc16f90 <strtol>
if ( endptr )
ffc105bc: 2f 9e 00 00 cmpwi cr7,r30,0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtol( s, &end, base );
ffc105c0: 7c 7c 1b 78 mr r28,r3
if ( endptr )
*endptr = end;
ffc105c4: 80 01 00 08 lwz r0,8(r1)
errno = 0;
*n = 0;
result = strtol( s, &end, base );
if ( endptr )
ffc105c8: 41 9e 00 08 beq- cr7,ffc105d0 <rtems_string_to_long+0x68>
*endptr = end;
ffc105cc: 90 1e 00 00 stw r0,0(r30)
if ( end == s )
ffc105d0: 7f 9f 00 00 cmpw cr7,r31,r0
return RTEMS_NOT_DEFINED;
ffc105d4: 38 60 00 0b li r3,11
result = strtol( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
ffc105d8: 41 9e 00 1c beq- cr7,ffc105f4 <rtems_string_to_long+0x8c>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc105dc: 48 00 39 ed bl ffc13fc8 <__errno>
ffc105e0: 80 03 00 00 lwz r0,0(r3)
ffc105e4: 2f 80 00 22 cmpwi cr7,r0,34
ffc105e8: 41 9e 00 2c beq- cr7,ffc10614 <rtems_string_to_long+0xac>
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
return RTEMS_INVALID_NUMBER;
*n = result;
ffc105ec: 93 9d 00 00 stw r28,0(r29)
return RTEMS_SUCCESSFUL;
ffc105f0: 38 60 00 00 li r3,0
}
ffc105f4: 80 01 00 2c lwz r0,44(r1)
ffc105f8: 83 81 00 18 lwz r28,24(r1)
ffc105fc: 7c 08 03 a6 mtlr r0
ffc10600: 83 a1 00 1c lwz r29,28(r1)
ffc10604: 83 c1 00 20 lwz r30,32(r1)
ffc10608: 83 e1 00 24 lwz r31,36(r1)
ffc1060c: 38 21 00 28 addi r1,r1,40
ffc10610: 4e 80 00 20 blr
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc10614: 2f 9c 00 00 cmpwi cr7,r28,0
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
return RTEMS_INVALID_NUMBER;
ffc10618: 38 60 00 0a li r3,10
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc1061c: 41 9e ff d8 beq+ cr7,ffc105f4 <rtems_string_to_long+0x8c><== NEVER TAKEN
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
ffc10620: 6f 80 80 00 xoris r0,r28,32768
ffc10624: 2f 80 ff ff cmpwi cr7,r0,-1
ffc10628: 41 9e ff cc beq+ cr7,ffc105f4 <rtems_string_to_long+0x8c>
ffc1062c: 3c 00 80 00 lis r0,-32768
ffc10630: 7f 9c 00 00 cmpw cr7,r28,r0
ffc10634: 40 9e ff b8 bne+ cr7,ffc105ec <rtems_string_to_long+0x84><== NEVER TAKEN
ffc10638: 4b ff ff bc b ffc105f4 <rtems_string_to_long+0x8c>
ffc10460 <rtems_string_to_long_long>:
const char *s,
long long *n,
char **endptr,
int base
)
{
ffc10460: 94 21 ff d0 stwu r1,-48(r1)
ffc10464: 7c 08 02 a6 mflr r0
ffc10468: 93 a1 00 24 stw r29,36(r1)
long long result;
char *end;
if ( !n )
ffc1046c: 7c 9d 23 79 mr. r29,r4
const char *s,
long long *n,
char **endptr,
int base
)
{
ffc10470: 93 81 00 20 stw r28,32(r1)
ffc10474: 7c dc 33 78 mr r28,r6
ffc10478: 93 c1 00 28 stw r30,40(r1)
ffc1047c: 7c be 2b 78 mr r30,r5
ffc10480: 93 e1 00 2c stw r31,44(r1)
ffc10484: 7c 7f 1b 78 mr r31,r3
long long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
ffc10488: 38 60 00 09 li r3,9
const char *s,
long long *n,
char **endptr,
int base
)
{
ffc1048c: 90 01 00 34 stw r0,52(r1)
ffc10490: 93 61 00 1c stw r27,28(r1)
long long result;
char *end;
if ( !n )
ffc10494: 41 82 00 70 beq- ffc10504 <rtems_string_to_long_long+0xa4>
return RTEMS_INVALID_ADDRESS;
errno = 0;
ffc10498: 48 00 3b 31 bl ffc13fc8 <__errno>
ffc1049c: 38 00 00 00 li r0,0
*n = 0;
ffc104a0: 39 40 00 00 li r10,0
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
ffc104a4: 90 03 00 00 stw r0,0(r3)
*n = 0;
ffc104a8: 39 60 00 00 li r11,0
ffc104ac: 91 5d 00 00 stw r10,0(r29)
result = strtoll( s, &end, base );
ffc104b0: 7f 85 e3 78 mr r5,r28
ffc104b4: 7f e3 fb 78 mr r3,r31
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
ffc104b8: 91 7d 00 04 stw r11,4(r29)
result = strtoll( s, &end, base );
ffc104bc: 38 81 00 08 addi r4,r1,8
ffc104c0: 48 00 6a f1 bl ffc16fb0 <strtoll>
if ( endptr )
ffc104c4: 2f 9e 00 00 cmpwi cr7,r30,0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoll( s, &end, base );
ffc104c8: 7c 7c 1b 78 mr r28,r3
if ( endptr )
*endptr = end;
ffc104cc: 80 01 00 08 lwz r0,8(r1)
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoll( s, &end, base );
ffc104d0: 7c 9b 23 78 mr r27,r4
if ( endptr )
ffc104d4: 41 9e 00 08 beq- cr7,ffc104dc <rtems_string_to_long_long+0x7c>
*endptr = end;
ffc104d8: 90 1e 00 00 stw r0,0(r30)
if ( end == s )
ffc104dc: 7f 9f 00 00 cmpw cr7,r31,r0
return RTEMS_NOT_DEFINED;
ffc104e0: 38 60 00 0b li r3,11
result = strtoll( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
ffc104e4: 41 9e 00 20 beq- cr7,ffc10504 <rtems_string_to_long_long+0xa4>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc104e8: 48 00 3a e1 bl ffc13fc8 <__errno>
ffc104ec: 80 03 00 00 lwz r0,0(r3)
ffc104f0: 2f 80 00 22 cmpwi cr7,r0,34
ffc104f4: 41 9e 00 34 beq- cr7,ffc10528 <rtems_string_to_long_long+0xc8>
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
return RTEMS_INVALID_NUMBER;
*n = result;
ffc104f8: 93 9d 00 00 stw r28,0(r29)
return RTEMS_SUCCESSFUL;
ffc104fc: 38 60 00 00 li r3,0
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
return RTEMS_INVALID_NUMBER;
*n = result;
ffc10500: 93 7d 00 04 stw r27,4(r29)
return RTEMS_SUCCESSFUL;
}
ffc10504: 80 01 00 34 lwz r0,52(r1)
ffc10508: 83 61 00 1c lwz r27,28(r1)
ffc1050c: 7c 08 03 a6 mtlr r0
ffc10510: 83 81 00 20 lwz r28,32(r1)
ffc10514: 83 a1 00 24 lwz r29,36(r1)
ffc10518: 83 c1 00 28 lwz r30,40(r1)
ffc1051c: 83 e1 00 2c lwz r31,44(r1)
ffc10520: 38 21 00 30 addi r1,r1,48
ffc10524: 4e 80 00 20 blr
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc10528: 7f 80 db 79 or. r0,r28,r27
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
return RTEMS_INVALID_NUMBER;
ffc1052c: 38 60 00 0a li r3,10
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc10530: 41 82 ff d4 beq+ ffc10504 <rtems_string_to_long_long+0xa4><== NEVER TAKEN
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
ffc10534: 6f 80 80 00 xoris r0,r28,32768
ffc10538: 2f 80 ff ff cmpwi cr7,r0,-1
ffc1053c: 41 9e 00 20 beq- cr7,ffc1055c <rtems_string_to_long_long+0xfc>
ffc10540: 3c 00 80 00 lis r0,-32768
ffc10544: 7f 9c 00 00 cmpw cr7,r28,r0
ffc10548: 40 9e ff b0 bne+ cr7,ffc104f8 <rtems_string_to_long_long+0x98><== NEVER TAKEN
ffc1054c: 2f 9b 00 00 cmpwi cr7,r27,0
return RTEMS_INVALID_NUMBER;
ffc10550: 38 60 00 0a li r3,10
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
ffc10554: 40 9e ff a4 bne+ cr7,ffc104f8 <rtems_string_to_long_long+0x98><== NEVER TAKEN
ffc10558: 4b ff ff ac b ffc10504 <rtems_string_to_long_long+0xa4>
ffc1055c: 2f 9b ff ff cmpwi cr7,r27,-1
ffc10560: 40 9e ff e0 bne+ cr7,ffc10540 <rtems_string_to_long_long+0xe0><== NEVER TAKEN
ffc10564: 4b ff ff a0 b ffc10504 <rtems_string_to_long_long+0xa4>
ffc10660 <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
ffc10660: 94 21 ff d8 stwu r1,-40(r1)
ffc10664: 7c 08 02 a6 mflr r0
ffc10668: 93 a1 00 1c stw r29,28(r1)
unsigned long result;
char *end;
if ( !n )
ffc1066c: 7c 9d 23 79 mr. r29,r4
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
ffc10670: 93 81 00 18 stw r28,24(r1)
ffc10674: 7c dc 33 78 mr r28,r6
ffc10678: 93 c1 00 20 stw r30,32(r1)
ffc1067c: 7c be 2b 78 mr r30,r5
ffc10680: 93 e1 00 24 stw r31,36(r1)
ffc10684: 7c 7f 1b 78 mr r31,r3
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
ffc10688: 38 60 00 09 li r3,9
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
ffc1068c: 90 01 00 2c stw r0,44(r1)
unsigned long result;
char *end;
if ( !n )
ffc10690: 41 82 00 64 beq- ffc106f4 <rtems_string_to_unsigned_char+0x94>
return RTEMS_INVALID_ADDRESS;
errno = 0;
ffc10694: 48 00 39 35 bl ffc13fc8 <__errno>
ffc10698: 38 00 00 00 li r0,0
ffc1069c: 90 03 00 00 stw r0,0(r3)
*n = 0;
result = strtoul( s, &end, base );
ffc106a0: 7f 85 e3 78 mr r5,r28
ffc106a4: 7f e3 fb 78 mr r3,r31
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
ffc106a8: 98 1d 00 00 stb r0,0(r29)
result = strtoul( s, &end, base );
ffc106ac: 38 81 00 08 addi r4,r1,8
ffc106b0: 48 00 6e 6d bl ffc1751c <strtoul>
if ( endptr )
ffc106b4: 2f 9e 00 00 cmpwi cr7,r30,0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
ffc106b8: 7c 7c 1b 78 mr r28,r3
if ( endptr )
*endptr = end;
ffc106bc: 80 01 00 08 lwz r0,8(r1)
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
if ( endptr )
ffc106c0: 41 9e 00 08 beq- cr7,ffc106c8 <rtems_string_to_unsigned_char+0x68>
*endptr = end;
ffc106c4: 90 1e 00 00 stw r0,0(r30)
if ( end == s )
ffc106c8: 7f 9f 00 00 cmpw cr7,r31,r0
return RTEMS_NOT_DEFINED;
ffc106cc: 38 60 00 0b li r3,11
result = strtoul( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
ffc106d0: 41 9e 00 24 beq- cr7,ffc106f4 <rtems_string_to_unsigned_char+0x94>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc106d4: 48 00 38 f5 bl ffc13fc8 <__errno>
ffc106d8: 80 03 00 00 lwz r0,0(r3)
ffc106dc: 2f 80 00 22 cmpwi cr7,r0,34
ffc106e0: 41 9e 00 64 beq- cr7,ffc10744 <rtems_string_to_unsigned_char+0xe4>
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
ffc106e4: 2b 9c 00 ff cmplwi cr7,r28,255
ffc106e8: 41 9d 00 2c bgt- cr7,ffc10714 <rtems_string_to_unsigned_char+0xb4>
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
ffc106ec: 9b 9d 00 00 stb r28,0(r29)
return RTEMS_SUCCESSFUL;
ffc106f0: 38 60 00 00 li r3,0
}
ffc106f4: 80 01 00 2c lwz r0,44(r1)
ffc106f8: 83 81 00 18 lwz r28,24(r1)
ffc106fc: 7c 08 03 a6 mtlr r0
ffc10700: 83 a1 00 1c lwz r29,28(r1)
ffc10704: 83 c1 00 20 lwz r30,32(r1)
ffc10708: 83 e1 00 24 lwz r31,36(r1)
ffc1070c: 38 21 00 28 addi r1,r1,40
ffc10710: 4e 80 00 20 blr
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
errno = ERANGE;
ffc10714: 48 00 38 b5 bl ffc13fc8 <__errno>
ffc10718: 38 00 00 22 li r0,34
ffc1071c: 90 03 00 00 stw r0,0(r3)
return RTEMS_INVALID_NUMBER;
ffc10720: 38 60 00 0a li r3,10
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
ffc10724: 80 01 00 2c lwz r0,44(r1)
ffc10728: 83 81 00 18 lwz r28,24(r1)
ffc1072c: 7c 08 03 a6 mtlr r0
ffc10730: 83 a1 00 1c lwz r29,28(r1)
ffc10734: 83 c1 00 20 lwz r30,32(r1)
ffc10738: 83 e1 00 24 lwz r31,36(r1)
ffc1073c: 38 21 00 28 addi r1,r1,40
ffc10740: 4e 80 00 20 blr
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
ffc10744: 39 3c ff ff addi r9,r28,-1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc10748: 38 00 ff fd li r0,-3
ffc1074c: 7f 89 00 40 cmplw cr7,r9,r0
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
ffc10750: 38 60 00 0a li r3,10
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc10754: 41 9d ff a0 bgt+ cr7,ffc106f4 <rtems_string_to_unsigned_char+0x94><== ALWAYS TAKEN
ffc10758: 4b ff ff 8c b ffc106e4 <rtems_string_to_unsigned_char+0x84><== NOT EXECUTED
ffc1075c <rtems_string_to_unsigned_int>:
const char *s,
unsigned int *n,
char **endptr,
int base
)
{
ffc1075c: 94 21 ff d8 stwu r1,-40(r1)
ffc10760: 7c 08 02 a6 mflr r0
ffc10764: 93 a1 00 1c stw r29,28(r1)
unsigned long result;
char *end;
if ( !n )
ffc10768: 7c 9d 23 79 mr. r29,r4
const char *s,
unsigned int *n,
char **endptr,
int base
)
{
ffc1076c: 93 81 00 18 stw r28,24(r1)
ffc10770: 7c dc 33 78 mr r28,r6
ffc10774: 93 c1 00 20 stw r30,32(r1)
ffc10778: 7c be 2b 78 mr r30,r5
ffc1077c: 93 e1 00 24 stw r31,36(r1)
ffc10780: 7c 7f 1b 78 mr r31,r3
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
ffc10784: 38 60 00 09 li r3,9
const char *s,
unsigned int *n,
char **endptr,
int base
)
{
ffc10788: 90 01 00 2c stw r0,44(r1)
unsigned long result;
char *end;
if ( !n )
ffc1078c: 41 82 00 5c beq- ffc107e8 <rtems_string_to_unsigned_int+0x8c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
ffc10790: 48 00 38 39 bl ffc13fc8 <__errno>
ffc10794: 38 00 00 00 li r0,0
ffc10798: 90 03 00 00 stw r0,0(r3)
*n = 0;
result = strtoul( s, &end, base );
ffc1079c: 7f 85 e3 78 mr r5,r28
ffc107a0: 7f e3 fb 78 mr r3,r31
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
ffc107a4: 90 1d 00 00 stw r0,0(r29)
result = strtoul( s, &end, base );
ffc107a8: 38 81 00 08 addi r4,r1,8
ffc107ac: 48 00 6d 71 bl ffc1751c <strtoul>
if ( endptr )
ffc107b0: 2f 9e 00 00 cmpwi cr7,r30,0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
ffc107b4: 7c 7c 1b 78 mr r28,r3
if ( endptr )
*endptr = end;
ffc107b8: 80 01 00 08 lwz r0,8(r1)
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
if ( endptr )
ffc107bc: 41 9e 00 08 beq- cr7,ffc107c4 <rtems_string_to_unsigned_int+0x68>
*endptr = end;
ffc107c0: 90 1e 00 00 stw r0,0(r30)
if ( end == s )
ffc107c4: 7f 9f 00 00 cmpw cr7,r31,r0
return RTEMS_NOT_DEFINED;
ffc107c8: 38 60 00 0b li r3,11
result = strtoul( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
ffc107cc: 41 9e 00 1c beq- cr7,ffc107e8 <rtems_string_to_unsigned_int+0x8c>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc107d0: 48 00 37 f9 bl ffc13fc8 <__errno>
ffc107d4: 80 03 00 00 lwz r0,0(r3)
ffc107d8: 2f 80 00 22 cmpwi cr7,r0,34
ffc107dc: 41 9e 00 2c beq- cr7,ffc10808 <rtems_string_to_unsigned_int+0xac>
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
ffc107e0: 93 9d 00 00 stw r28,0(r29)
return RTEMS_SUCCESSFUL;
ffc107e4: 38 60 00 00 li r3,0
}
ffc107e8: 80 01 00 2c lwz r0,44(r1)
ffc107ec: 83 81 00 18 lwz r28,24(r1)
ffc107f0: 7c 08 03 a6 mtlr r0
ffc107f4: 83 a1 00 1c lwz r29,28(r1)
ffc107f8: 83 c1 00 20 lwz r30,32(r1)
ffc107fc: 83 e1 00 24 lwz r31,36(r1)
ffc10800: 38 21 00 28 addi r1,r1,40
ffc10804: 4e 80 00 20 blr
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
ffc10808: 39 3c ff ff addi r9,r28,-1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc1080c: 38 00 ff fd li r0,-3
ffc10810: 7f 89 00 40 cmplw cr7,r9,r0
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
ffc10814: 38 60 00 0a li r3,10
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc10818: 41 9d ff d0 bgt+ cr7,ffc107e8 <rtems_string_to_unsigned_int+0x8c><== ALWAYS TAKEN
ffc1081c: 4b ff ff c4 b ffc107e0 <rtems_string_to_unsigned_int+0x84><== NOT EXECUTED
ffc10914 <rtems_string_to_unsigned_long>:
const char *s,
unsigned long *n,
char **endptr,
int base
)
{
ffc10914: 94 21 ff d8 stwu r1,-40(r1)
ffc10918: 7c 08 02 a6 mflr r0
ffc1091c: 93 a1 00 1c stw r29,28(r1)
unsigned long result;
char *end;
if ( !n )
ffc10920: 7c 9d 23 79 mr. r29,r4
const char *s,
unsigned long *n,
char **endptr,
int base
)
{
ffc10924: 93 81 00 18 stw r28,24(r1)
ffc10928: 7c dc 33 78 mr r28,r6
ffc1092c: 93 c1 00 20 stw r30,32(r1)
ffc10930: 7c be 2b 78 mr r30,r5
ffc10934: 93 e1 00 24 stw r31,36(r1)
ffc10938: 7c 7f 1b 78 mr r31,r3
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
ffc1093c: 38 60 00 09 li r3,9
const char *s,
unsigned long *n,
char **endptr,
int base
)
{
ffc10940: 90 01 00 2c stw r0,44(r1)
unsigned long result;
char *end;
if ( !n )
ffc10944: 41 82 00 5c beq- ffc109a0 <rtems_string_to_unsigned_long+0x8c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
ffc10948: 48 00 36 81 bl ffc13fc8 <__errno>
ffc1094c: 38 00 00 00 li r0,0
ffc10950: 90 03 00 00 stw r0,0(r3)
*n = 0;
result = strtoul( s, &end, base );
ffc10954: 7f 85 e3 78 mr r5,r28
ffc10958: 7f e3 fb 78 mr r3,r31
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
ffc1095c: 90 1d 00 00 stw r0,0(r29)
result = strtoul( s, &end, base );
ffc10960: 38 81 00 08 addi r4,r1,8
ffc10964: 48 00 6b b9 bl ffc1751c <strtoul>
if ( endptr )
ffc10968: 2f 9e 00 00 cmpwi cr7,r30,0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
ffc1096c: 7c 7c 1b 78 mr r28,r3
if ( endptr )
*endptr = end;
ffc10970: 80 01 00 08 lwz r0,8(r1)
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
if ( endptr )
ffc10974: 41 9e 00 08 beq- cr7,ffc1097c <rtems_string_to_unsigned_long+0x68>
*endptr = end;
ffc10978: 90 1e 00 00 stw r0,0(r30)
if ( end == s )
ffc1097c: 7f 9f 00 00 cmpw cr7,r31,r0
return RTEMS_NOT_DEFINED;
ffc10980: 38 60 00 0b li r3,11
result = strtoul( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
ffc10984: 41 9e 00 1c beq- cr7,ffc109a0 <rtems_string_to_unsigned_long+0x8c>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc10988: 48 00 36 41 bl ffc13fc8 <__errno>
ffc1098c: 80 03 00 00 lwz r0,0(r3)
ffc10990: 2f 80 00 22 cmpwi cr7,r0,34
ffc10994: 41 9e 00 2c beq- cr7,ffc109c0 <rtems_string_to_unsigned_long+0xac>
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
ffc10998: 93 9d 00 00 stw r28,0(r29)
return RTEMS_SUCCESSFUL;
ffc1099c: 38 60 00 00 li r3,0
}
ffc109a0: 80 01 00 2c lwz r0,44(r1)
ffc109a4: 83 81 00 18 lwz r28,24(r1)
ffc109a8: 7c 08 03 a6 mtlr r0
ffc109ac: 83 a1 00 1c lwz r29,28(r1)
ffc109b0: 83 c1 00 20 lwz r30,32(r1)
ffc109b4: 83 e1 00 24 lwz r31,36(r1)
ffc109b8: 38 21 00 28 addi r1,r1,40
ffc109bc: 4e 80 00 20 blr
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
ffc109c0: 39 3c ff ff addi r9,r28,-1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc109c4: 38 00 ff fd li r0,-3
ffc109c8: 7f 89 00 40 cmplw cr7,r9,r0
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
ffc109cc: 38 60 00 0a li r3,10
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc109d0: 41 9d ff d0 bgt+ cr7,ffc109a0 <rtems_string_to_unsigned_long+0x8c><== ALWAYS TAKEN
ffc109d4: 4b ff ff c4 b ffc10998 <rtems_string_to_unsigned_long+0x84><== NOT EXECUTED
ffc10820 <rtems_string_to_unsigned_long_long>:
const char *s,
unsigned long long *n,
char **endptr,
int base
)
{
ffc10820: 94 21 ff d0 stwu r1,-48(r1)
ffc10824: 7c 08 02 a6 mflr r0
ffc10828: 93 a1 00 24 stw r29,36(r1)
unsigned long long result;
char *end;
if ( !n )
ffc1082c: 7c 9d 23 79 mr. r29,r4
const char *s,
unsigned long long *n,
char **endptr,
int base
)
{
ffc10830: 93 81 00 20 stw r28,32(r1)
ffc10834: 7c dc 33 78 mr r28,r6
ffc10838: 93 c1 00 28 stw r30,40(r1)
ffc1083c: 7c be 2b 78 mr r30,r5
ffc10840: 93 e1 00 2c stw r31,44(r1)
ffc10844: 7c 7f 1b 78 mr r31,r3
unsigned long long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
ffc10848: 38 60 00 09 li r3,9
const char *s,
unsigned long long *n,
char **endptr,
int base
)
{
ffc1084c: 90 01 00 34 stw r0,52(r1)
ffc10850: 93 41 00 18 stw r26,24(r1)
ffc10854: 93 61 00 1c stw r27,28(r1)
unsigned long long result;
char *end;
if ( !n )
ffc10858: 41 82 00 70 beq- ffc108c8 <rtems_string_to_unsigned_long_long+0xa8>
return RTEMS_INVALID_ADDRESS;
errno = 0;
ffc1085c: 48 00 37 6d bl ffc13fc8 <__errno>
ffc10860: 38 00 00 00 li r0,0
*n = 0;
ffc10864: 39 40 00 00 li r10,0
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
ffc10868: 90 03 00 00 stw r0,0(r3)
*n = 0;
ffc1086c: 39 60 00 00 li r11,0
ffc10870: 91 5d 00 00 stw r10,0(r29)
result = strtoull( s, &end, base );
ffc10874: 7f e3 fb 78 mr r3,r31
ffc10878: 38 81 00 08 addi r4,r1,8
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
ffc1087c: 91 7d 00 04 stw r11,4(r29)
result = strtoull( s, &end, base );
ffc10880: 7f 85 e3 78 mr r5,r28
ffc10884: 48 00 6c b9 bl ffc1753c <strtoull>
if ( endptr )
ffc10888: 2f 9e 00 00 cmpwi cr7,r30,0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoull( s, &end, base );
ffc1088c: 7c 9b 23 78 mr r27,r4
if ( endptr )
*endptr = end;
ffc10890: 80 01 00 08 lwz r0,8(r1)
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoull( s, &end, base );
ffc10894: 7c 7a 1b 78 mr r26,r3
if ( endptr )
ffc10898: 41 9e 00 08 beq- cr7,ffc108a0 <rtems_string_to_unsigned_long_long+0x80>
*endptr = end;
ffc1089c: 90 1e 00 00 stw r0,0(r30)
if ( end == s )
ffc108a0: 7f 9f 00 00 cmpw cr7,r31,r0
return RTEMS_NOT_DEFINED;
ffc108a4: 38 60 00 0b li r3,11
result = strtoull( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
ffc108a8: 41 9e 00 20 beq- cr7,ffc108c8 <rtems_string_to_unsigned_long_long+0xa8>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc108ac: 48 00 37 1d bl ffc13fc8 <__errno>
ffc108b0: 80 03 00 00 lwz r0,0(r3)
ffc108b4: 2f 80 00 22 cmpwi cr7,r0,34
ffc108b8: 41 9e 00 38 beq- cr7,ffc108f0 <rtems_string_to_unsigned_long_long+0xd0>
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
ffc108bc: 93 5d 00 00 stw r26,0(r29)
return RTEMS_SUCCESSFUL;
ffc108c0: 38 60 00 00 li r3,0
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
ffc108c4: 93 7d 00 04 stw r27,4(r29)
return RTEMS_SUCCESSFUL;
}
ffc108c8: 80 01 00 34 lwz r0,52(r1)
ffc108cc: 83 41 00 18 lwz r26,24(r1)
ffc108d0: 7c 08 03 a6 mtlr r0
ffc108d4: 83 61 00 1c lwz r27,28(r1)
ffc108d8: 83 81 00 20 lwz r28,32(r1)
ffc108dc: 83 a1 00 24 lwz r29,36(r1)
ffc108e0: 83 c1 00 28 lwz r30,40(r1)
ffc108e4: 83 e1 00 2c lwz r31,44(r1)
ffc108e8: 38 21 00 30 addi r1,r1,48
ffc108ec: 4e 80 00 20 blr
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
ffc108f0: 31 7b ff ff addic r11,r27,-1
ffc108f4: 7d 5a 01 d4 addme r10,r26
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc108f8: 2f 8a ff ff cmpwi cr7,r10,-1
ffc108fc: 40 be ff c0 bne- cr7,ffc108bc <rtems_string_to_unsigned_long_long+0x9c><== NEVER TAKEN
ffc10900: 38 00 ff fd li r0,-3
ffc10904: 7f 8b 00 40 cmplw cr7,r11,r0
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
ffc10908: 38 60 00 0a li r3,10
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc1090c: 41 9d ff bc bgt+ cr7,ffc108c8 <rtems_string_to_unsigned_long_long+0xa8><== ALWAYS TAKEN
ffc10910: 4b ff ff ac b ffc108bc <rtems_string_to_unsigned_long_long+0x9c><== NOT EXECUTED
ffc04448 <rtems_tarfs_load>:
int rtems_tarfs_load(
char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
ffc04448: 94 21 fe 38 stwu r1,-456(r1)
ffc0444c: 7c 08 02 a6 mflr r0
ffc04450: 93 21 01 ac stw r25,428(r1)
ffc04454: 90 01 01 cc stw r0,460(r1)
ffc04458: 93 41 01 b0 stw r26,432(r1)
ffc0445c: 7c 7a 1b 78 mr r26,r3
ffc04460: 93 a1 01 bc stw r29,444(r1)
ffc04464: 7c bd 2b 78 mr r29,r5
ffc04468: 93 c1 01 c0 stw r30,448(r1)
ffc0446c: 7c 9e 23 78 mr r30,r4
ffc04470: 92 81 01 98 stw r20,408(r1)
ffc04474: 92 a1 01 9c stw r21,412(r1)
ffc04478: 92 c1 01 a0 stw r22,416(r1)
ffc0447c: 92 e1 01 a4 stw r23,420(r1)
ffc04480: 93 01 01 a8 stw r24,424(r1)
ffc04484: 93 61 01 b4 stw r27,436(r1)
ffc04488: 93 81 01 b8 stw r28,440(r1)
ffc0448c: 93 e1 01 c4 stw r31,452(r1)
int offset;
unsigned long nblocks;
IMFS_jnode_t *node;
int status;
status = rtems_filesystem_evaluate_path(
ffc04490: 48 01 4e 31 bl ffc192c0 <strlen>
ffc04494: 7c 64 1b 78 mr r4,r3
ffc04498: 38 a0 00 00 li r5,0
ffc0449c: 7f 43 d3 78 mr r3,r26
ffc044a0: 38 c1 00 20 addi r6,r1,32
ffc044a4: 38 e0 00 00 li r7,0
ffc044a8: 48 00 0e 8d bl ffc05334 <rtems_filesystem_evaluate_path>
strlen(mountpoint),
0,
&root_loc,
0
);
if (status != 0)
ffc044ac: 7c 79 1b 79 mr. r25,r3
ffc044b0: 40 82 01 f0 bne- ffc046a0 <rtems_tarfs_load+0x258>
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
ffc044b4: 80 01 00 2c lwz r0,44(r1)
ffc044b8: 3d 20 ff c2 lis r9,-62
ffc044bc: 39 29 5a 88 addi r9,r9,23176
ffc044c0: 7f 80 48 00 cmpw cr7,r0,r9
ffc044c4: 41 9e 00 14 beq- cr7,ffc044d8 <rtems_tarfs_load+0x90>
ffc044c8: 3d 20 ff c2 lis r9,-62
ffc044cc: 39 29 62 08 addi r9,r9,25096
ffc044d0: 7f 80 48 00 cmpw cr7,r0,r9
ffc044d4: 40 9e 01 cc bne- cr7,ffc046a0 <rtems_tarfs_load+0x258> <== ALWAYS TAKEN
ffc044d8: 3a e0 00 00 li r23,0
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while (1) {
if (offset + 512 > tar_size)
ffc044dc: 3b f7 02 00 addi r31,r23,512
ffc044e0: 7f 9f e8 40 cmplw cr7,r31,r29
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
ffc044e4: 3f 60 ff c2 lis r27,-62
ffc044e8: 3b 7b 5a d0 addi r27,r27,23248
* - 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, "/");
ffc044ec: 3b 00 2f 00 li r24,12032
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while (1) {
if (offset + 512 > tar_size)
ffc044f0: 41 9d 00 98 bgt- cr7,ffc04588 <rtems_tarfs_load+0x140> <== NEVER TAKEN
break;
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
ffc044f4: 7e fe ba 14 add r23,r30,r23
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
ffc044f8: 38 77 01 01 addi r3,r23,257
ffc044fc: 7f 64 db 78 mr r4,r27
ffc04500: 38 a0 00 05 li r5,5
ffc04504: 48 01 4e 79 bl ffc1937c <strncmp>
ffc04508: 7c 7c 1b 79 mr. r28,r3
ffc0450c: 40 82 00 7c bne- ffc04588 <rtems_tarfs_load+0x140>
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
ffc04510: 38 a0 00 63 li r5,99
ffc04514: 7e e4 bb 78 mr r4,r23
ffc04518: 38 61 00 34 addi r3,r1,52
ffc0451c: 48 01 4f a9 bl ffc194c4 <strncpy>
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
ffc04520: 38 80 00 08 li r4,8
ffc04524: 38 77 00 64 addi r3,r23,100
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
filename[MAX_NAME_FIELD_SIZE] = '\0';
ffc04528: 9b 81 00 97 stb r28,151(r1)
linkflag = hdr_ptr[156];
ffc0452c: 8a b7 00 9c lbz r21,156(r23)
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
ffc04530: 48 00 9e 6d bl ffc0e39c <_rtems_octal2ulong>
ffc04534: 7c 76 1b 78 mr r22,r3
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
ffc04538: 38 80 00 0c li r4,12
ffc0453c: 38 77 00 7c addi r3,r23,124
ffc04540: 48 00 9e 5d bl ffc0e39c <_rtems_octal2ulong>
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
ffc04544: 38 80 00 08 li r4,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);
ffc04548: 7c 7c 1b 78 mr r28,r3
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
ffc0454c: 38 77 00 94 addi r3,r23,148
ffc04550: 48 00 9e 4d bl ffc0e39c <_rtems_octal2ulong>
ffc04554: 7c 74 1b 78 mr r20,r3
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
ffc04558: 7e e3 bb 78 mr r3,r23
ffc0455c: 48 00 a4 11 bl ffc0e96c <_rtems_tar_header_checksum>
ffc04560: 7f 83 a0 00 cmpw cr7,r3,r20
ffc04564: 40 9e 00 24 bne- cr7,ffc04588 <rtems_tarfs_load+0x140> <== 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) {
ffc04568: 2f 95 00 35 cmpwi cr7,r21,53
ffc0456c: 41 9e 00 b4 beq- cr7,ffc04620 <rtems_tarfs_load+0x1d8>
* 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) {
ffc04570: 2f 95 00 30 cmpwi cr7,r21,48
ffc04574: 41 9e 00 58 beq- cr7,ffc045cc <rtems_tarfs_load+0x184>
0
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
ffc04578: 7f f7 fb 78 mr r23,r31
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while (1) {
if (offset + 512 > tar_size)
ffc0457c: 3b f7 02 00 addi r31,r23,512
ffc04580: 7f 9f e8 40 cmplw cr7,r31,r29
ffc04584: 40 9d ff 70 ble+ cr7,ffc044f4 <rtems_tarfs_load+0xac> <== ALWAYS TAKEN
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
}
}
return status;
}
ffc04588: 80 01 01 cc lwz r0,460(r1)
ffc0458c: 7f 23 cb 78 mr r3,r25
ffc04590: 82 81 01 98 lwz r20,408(r1)
ffc04594: 7c 08 03 a6 mtlr r0
ffc04598: 82 a1 01 9c lwz r21,412(r1)
ffc0459c: 82 c1 01 a0 lwz r22,416(r1)
ffc045a0: 82 e1 01 a4 lwz r23,420(r1)
ffc045a4: 83 01 01 a8 lwz r24,424(r1)
ffc045a8: 83 21 01 ac lwz r25,428(r1)
ffc045ac: 83 41 01 b0 lwz r26,432(r1)
ffc045b0: 83 61 01 b4 lwz r27,436(r1)
ffc045b4: 83 81 01 b8 lwz r28,440(r1)
ffc045b8: 83 a1 01 bc lwz r29,444(r1)
ffc045bc: 83 c1 01 c0 lwz r30,448(r1)
ffc045c0: 83 e1 01 c4 lwz r31,452(r1)
ffc045c4: 38 21 01 c8 addi r1,r1,456
ffc045c8: 4e 80 00 20 blr
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
ffc045cc: 80 01 00 20 lwz r0,32(r1)
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
ffc045d0: 38 61 00 34 addi r3,r1,52
ffc045d4: 38 81 00 0c addi r4,r1,12
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
ffc045d8: 90 01 00 0c stw r0,12(r1)
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
ffc045dc: 38 a1 00 08 addi r5,r1,8
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
ffc045e0: 80 01 00 24 lwz r0,36(r1)
ffc045e4: 90 01 00 10 stw r0,16(r1)
ffc045e8: 80 01 00 28 lwz r0,40(r1)
ffc045ec: 90 01 00 14 stw r0,20(r1)
ffc045f0: 80 01 00 2c lwz r0,44(r1)
ffc045f4: 90 01 00 18 stw r0,24(r1)
ffc045f8: 80 01 00 30 lwz r0,48(r1)
ffc045fc: 90 01 00 1c stw r0,28(r1)
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
ffc04600: 48 00 b0 21 bl ffc0f620 <IMFS_evaluate_for_make>
ffc04604: 7c 77 1b 79 mr. r23,r3
ffc04608: 41 82 00 68 beq- ffc04670 <rtems_tarfs_load+0x228> <== ALWAYS TAKEN
);
node->info.linearfile.size = file_size;
node->info.linearfile.direct = &tar_image[offset];
}
nblocks = (((file_size) + 511) & ~511) / 512;
ffc0460c: 3b 9c 01 ff addi r28,r28,511
offset += 512 * nblocks;
ffc04610: 57 9c 00 2c rlwinm r28,r28,0,0,22
ffc04614: 7f fc fa 14 add r31,r28,r31
0
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
ffc04618: 7f f7 fb 78 mr r23,r31
ffc0461c: 4b ff ff 60 b ffc0457c <rtems_tarfs_load+0x134>
* - 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);
ffc04620: 7f 44 d3 78 mr r4,r26
ffc04624: 38 61 00 98 addi r3,r1,152
ffc04628: 48 01 47 85 bl ffc18dac <strcpy>
if (full_filename[strlen(full_filename)-1] != '/')
ffc0462c: 38 61 00 98 addi r3,r1,152
ffc04630: 48 01 4c 91 bl ffc192c0 <strlen>
ffc04634: 38 01 00 08 addi r0,r1,8
ffc04638: 7d 20 1a 14 add r9,r0,r3
ffc0463c: 88 09 00 8f lbz r0,143(r9)
ffc04640: 2f 80 00 2f cmpwi cr7,r0,47
ffc04644: 41 9e 00 0c beq- cr7,ffc04650 <rtems_tarfs_load+0x208> <== ALWAYS TAKEN
strcat(full_filename, "/");
ffc04648: 39 21 00 98 addi r9,r1,152 <== NOT EXECUTED
ffc0464c: 7f 09 1b 2e sthx r24,r9,r3 <== NOT EXECUTED
strcat(full_filename, filename);
ffc04650: 38 81 00 34 addi r4,r1,52
ffc04654: 38 61 00 98 addi r3,r1,152
ffc04658: 48 01 45 f5 bl ffc18c4c <strcat>
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
ffc0465c: 38 61 00 98 addi r3,r1,152
ffc04660: 38 80 01 ff li r4,511
ffc04664: 48 00 18 99 bl ffc05efc <mkdir>
0
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
ffc04668: 7f f7 fb 78 mr r23,r31
ffc0466c: 4b ff ff 10 b ffc0457c <rtems_tarfs_load+0x134>
loc = root_loc;
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
node = IMFS_create_node(
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
ffc04670: 56 c6 05 fe clrlwi r6,r22,23
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
node = IMFS_create_node(
ffc04674: 80 a1 00 08 lwz r5,8(r1)
ffc04678: 38 61 00 0c addi r3,r1,12
ffc0467c: 38 80 00 06 li r4,6
ffc04680: 60 c6 80 00 ori r6,r6,32768
ffc04684: 38 e0 00 00 li r7,0
ffc04688: 48 00 a5 e1 bl ffc0ec68 <IMFS_create_node>
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
NULL
);
node->info.linearfile.size = file_size;
node->info.linearfile.direct = &tar_image[offset];
ffc0468c: 7c 1e fa 14 add r0,r30,r31
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
NULL
);
node->info.linearfile.size = file_size;
ffc04690: 93 83 00 54 stw r28,84(r3)
ffc04694: 92 e3 00 50 stw r23,80(r3)
node->info.linearfile.direct = &tar_image[offset];
ffc04698: 90 03 00 58 stw r0,88(r3)
ffc0469c: 4b ff ff 70 b ffc0460c <rtems_tarfs_load+0x1c4>
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
return -1;
ffc046a0: 3b 20 ff ff li r25,-1
ffc046a4: 4b ff fe e4 b ffc04588 <rtems_tarfs_load+0x140>
ffc136b4 <rtems_task_mode>:
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
ffc136b4: 2c 05 00 00 cmpwi r5,0
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
ffc136b8: 7c 08 02 a6 mflr r0
ffc136bc: 94 21 ff f8 stwu r1,-8(r1)
ffc136c0: 90 01 00 0c stw r0,12(r1)
ffc136c4: 7c 60 1b 78 mr r0,r3
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
ffc136c8: 38 60 00 09 li r3,9
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
ffc136cc: 41 82 01 34 beq- ffc13800 <rtems_task_mode+0x14c>
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
ffc136d0: 3c c0 00 00 lis r6,0
ffc136d4: 38 c6 31 44 addi r6,r6,12612
ffc136d8: 81 26 00 0c lwz r9,12(r6)
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
ffc136dc: 81 69 00 7c lwz r11,124(r9)
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
ffc136e0: 89 09 00 74 lbz r8,116(r9)
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
ffc136e4: 2f 8b 00 00 cmpwi cr7,r11,0
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
ffc136e8: 81 69 01 30 lwz r11,304(r9)
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
ffc136ec: 7d 08 00 34 cntlzw r8,r8
ffc136f0: 55 08 d9 7e rlwinm r8,r8,27,5,31
ffc136f4: 55 07 40 2e rlwinm r7,r8,8,0,23
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
ffc136f8: 40 9e 01 18 bne- cr7,ffc13810 <rtems_task_mode+0x15c>
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
ffc136fc: 89 0b 00 08 lbz r8,8(r11)
#ifndef ASM
static inline uint32_t _CPU_ISR_Get_level( void )
{
register unsigned int msr;
_CPU_MSR_GET(msr);
ffc13700: 39 40 00 00 li r10,0
ffc13704: 7d 08 00 34 cntlzw r8,r8
ffc13708: 55 08 d9 7e rlwinm r8,r8,27,5,31
ffc1370c: 55 08 50 2a rlwinm r8,r8,10,0,21
ffc13710: 7d 07 3b 78 or r7,r8,r7
ffc13714: 7d 40 00 a6 mfmsr r10
if (msr & MSR_EE) return 0;
ffc13718: 55 48 8f fe rlwinm r8,r10,17,31,31
ffc1371c: 2f 88 00 00 cmpwi cr7,r8,0
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
ffc13720: 70 8a 01 00 andi. r10,r4,256
ffc13724: 7d 40 00 26 mfcr r10
ffc13728: 55 4a ff fe rlwinm r10,r10,31,31,31
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
old_mode |= _ISR_Get_level();
ffc1372c: 7c e7 53 78 or r7,r7,r10
*previous_mode_set = old_mode;
ffc13730: 90 e5 00 00 stw r7,0(r5)
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
ffc13734: 41 82 00 14 beq- ffc13748 <rtems_task_mode+0x94>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
ffc13738: 70 08 01 00 andi. r8,r0,256
ffc1373c: 7d 40 00 26 mfcr r10
ffc13740: 55 4a 1f fe rlwinm r10,r10,3,31,31
ffc13744: 99 49 00 74 stb r10,116(r9)
if ( mask & RTEMS_TIMESLICE_MASK ) {
ffc13748: 70 8a 02 00 andi. r10,r4,512
ffc1374c: 41 82 00 20 beq- ffc1376c <rtems_task_mode+0xb8>
if ( _Modes_Is_timeslice(mode_set) ) {
ffc13750: 70 0a 02 00 andi. r10,r0,512
ffc13754: 41 82 01 44 beq- ffc13898 <rtems_task_mode+0x1e4>
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
ffc13758: 3d 40 00 00 lis r10,0
ffc1375c: 81 4a 28 08 lwz r10,10248(r10)
if ( mask & RTEMS_PREEMPT_MASK )
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
ffc13760: 39 00 00 01 li r8,1
ffc13764: 91 09 00 7c stw r8,124(r9)
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
ffc13768: 91 49 00 78 stw r10,120(r9)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
ffc1376c: 70 88 00 01 andi. r8,r4,1
ffc13770: 41 82 00 20 beq- ffc13790 <rtems_task_mode+0xdc>
}
static inline void _CPU_ISR_Set_level( uint32_t level )
{
register unsigned int msr;
_CPU_MSR_GET(msr);
ffc13774: 39 20 00 00 li r9,0
ffc13778: 7d 20 00 a6 mfmsr r9
if (!(level & CPU_MODES_INTERRUPT_MASK)) {
ffc1377c: 70 0a 00 01 andi. r10,r0,1
static inline uint32_t ppc_interrupt_get_disable_mask( void )
{
uint32_t mask;
__asm__ volatile (
ffc13780: 7d 50 42 a6 mfsprg r10,0
ffc13784: 40 82 01 24 bne- ffc138a8 <rtems_task_mode+0x1f4>
msr |= ppc_interrupt_get_disable_mask();
ffc13788: 7d 49 4b 78 or r9,r10,r9
}
else {
msr &= ~ppc_interrupt_get_disable_mask();
}
_CPU_MSR_SET(msr);
ffc1378c: 7d 20 01 24 mtmsr r9
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
ffc13790: 70 88 04 00 andi. r8,r4,1024
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
ffc13794: 39 40 00 00 li r10,0
if ( mask & RTEMS_ASR_MASK ) {
ffc13798: 41 82 00 54 beq- ffc137ec <rtems_task_mode+0x138>
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
ffc1379c: 70 09 04 00 andi. r9,r0,1024
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 ) {
ffc137a0: 89 2b 00 08 lbz r9,8(r11)
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
ffc137a4: 7c 00 00 26 mfcr r0
ffc137a8: 54 00 1f fe rlwinm r0,r0,3,31,31
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 ) {
ffc137ac: 7f 89 00 00 cmpw cr7,r9,r0
ffc137b0: 41 9e 00 3c beq- cr7,ffc137ec <rtems_task_mode+0x138>
asr->is_enabled = is_asr_enabled;
ffc137b4: 98 0b 00 08 stb r0,8(r11)
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc137b8: 7c 00 00 a6 mfmsr r0
ffc137bc: 7d 30 42 a6 mfsprg r9,0
ffc137c0: 7c 09 48 78 andc r9,r0,r9
ffc137c4: 7d 20 01 24 mtmsr r9
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
ffc137c8: 81 4b 00 18 lwz r10,24(r11)
information->signals_pending = information->signals_posted;
ffc137cc: 81 2b 00 14 lwz r9,20(r11)
information->signals_posted = _signals;
ffc137d0: 91 4b 00 14 stw r10,20(r11)
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
information->signals_pending = information->signals_posted;
ffc137d4: 91 2b 00 18 stw r9,24(r11)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc137d8: 7c 00 01 24 mtmsr r0
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
ffc137dc: 80 0b 00 14 lwz r0,20(r11)
needs_asr_dispatching = true;
ffc137e0: 39 40 00 01 li r10,1
if ( mask & RTEMS_ASR_MASK ) {
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
asr->is_enabled = is_asr_enabled;
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
ffc137e4: 2f 80 00 00 cmpwi cr7,r0,0
ffc137e8: 41 9e 00 cc beq- cr7,ffc138b4 <rtems_task_mode+0x200>
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
ffc137ec: 3d 20 00 00 lis r9,0
ffc137f0: 80 09 28 48 lwz r0,10312(r9)
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
ffc137f4: 38 60 00 00 li r3,0
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
ffc137f8: 2f 80 00 03 cmpwi cr7,r0,3
ffc137fc: 41 9e 00 58 beq- cr7,ffc13854 <rtems_task_mode+0x1a0>
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
}
ffc13800: 80 01 00 0c lwz r0,12(r1)
ffc13804: 38 21 00 08 addi r1,r1,8
ffc13808: 7c 08 03 a6 mtlr r0
ffc1380c: 4e 80 00 20 blr
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;
ffc13810: 89 0b 00 08 lbz r8,8(r11)
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
ffc13814: 60 e7 02 00 ori r7,r7,512
#ifndef ASM
static inline uint32_t _CPU_ISR_Get_level( void )
{
register unsigned int msr;
_CPU_MSR_GET(msr);
ffc13818: 39 40 00 00 li r10,0
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
ffc1381c: 7d 08 00 34 cntlzw r8,r8
ffc13820: 55 08 d9 7e rlwinm r8,r8,27,5,31
ffc13824: 55 08 50 2a rlwinm r8,r8,10,0,21
ffc13828: 7d 07 3b 78 or r7,r8,r7
ffc1382c: 7d 40 00 a6 mfmsr r10
if (msr & MSR_EE) return 0;
ffc13830: 55 48 8f fe rlwinm r8,r10,17,31,31
ffc13834: 2f 88 00 00 cmpwi cr7,r8,0
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
ffc13838: 70 8a 01 00 andi. r10,r4,256
ffc1383c: 7d 40 00 26 mfcr r10
ffc13840: 55 4a ff fe rlwinm r10,r10,31,31,31
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
old_mode |= _ISR_Get_level();
ffc13844: 7c e7 53 78 or r7,r7,r10
*previous_mode_set = old_mode;
ffc13848: 90 e5 00 00 stw r7,0(r5)
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
ffc1384c: 41 a2 fe fc beq- ffc13748 <rtems_task_mode+0x94>
ffc13850: 4b ff fe e8 b ffc13738 <rtems_task_mode+0x84>
{
Thread_Control *executing;
executing = _Thread_Executing;
if ( are_signals_pending ||
ffc13854: 2f 8a 00 00 cmpwi cr7,r10,0
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
ffc13858: 81 26 00 0c lwz r9,12(r6)
if ( are_signals_pending ||
ffc1385c: 40 9e 00 1c bne- cr7,ffc13878 <rtems_task_mode+0x1c4>
ffc13860: 80 06 00 10 lwz r0,16(r6)
ffc13864: 7f 89 00 00 cmpw cr7,r9,r0
ffc13868: 41 be ff 98 beq- cr7,ffc13800 <rtems_task_mode+0x14c>
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
ffc1386c: 88 09 00 74 lbz r0,116(r9)
ffc13870: 2f 80 00 00 cmpwi cr7,r0,0
ffc13874: 41 be ff 8c beq- cr7,ffc13800 <rtems_task_mode+0x14c> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
ffc13878: 38 00 00 01 li r0,1
ffc1387c: 98 06 00 18 stb r0,24(r6)
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
ffc13880: 4b ff 8a a9 bl ffc0c328 <_Thread_Dispatch>
}
return RTEMS_SUCCESSFUL;
}
ffc13884: 80 01 00 0c lwz r0,12(r1)
if ( _System_state_Is_up( _System_state_Get() ) ) {
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
ffc13888: 38 60 00 00 li r3,0
}
ffc1388c: 7c 08 03 a6 mtlr r0
ffc13890: 38 21 00 08 addi r1,r1,8
ffc13894: 4e 80 00 20 blr
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
ffc13898: 70 88 00 01 andi. r8,r4,1
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
ffc1389c: 91 49 00 7c stw r10,124(r9)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
ffc138a0: 41 a2 fe f0 beq- ffc13790 <rtems_task_mode+0xdc>
ffc138a4: 4b ff fe d0 b ffc13774 <rtems_task_mode+0xc0>
_CPU_MSR_GET(msr);
if (!(level & CPU_MODES_INTERRUPT_MASK)) {
msr |= ppc_interrupt_get_disable_mask();
}
else {
msr &= ~ppc_interrupt_get_disable_mask();
ffc138a8: 7d 29 50 78 andc r9,r9,r10
}
_CPU_MSR_SET(msr);
ffc138ac: 7d 20 01 24 mtmsr r9
*/
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
Modes_Control mode_set
)
{
_ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
ffc138b0: 4b ff fe e0 b ffc13790 <rtems_task_mode+0xdc>
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
ffc138b4: 3d 20 00 00 lis r9,0
ffc138b8: 80 09 28 48 lwz r0,10312(r9)
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
ffc138bc: 39 40 00 00 li r10,0
if ( _System_state_Is_up( _System_state_Get() ) ) {
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
ffc138c0: 38 60 00 00 li r3,0
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
ffc138c4: 2f 80 00 03 cmpwi cr7,r0,3
ffc138c8: 40 9e ff 38 bne+ cr7,ffc13800 <rtems_task_mode+0x14c> <== NEVER TAKEN
ffc138cc: 4b ff ff 88 b ffc13854 <rtems_task_mode+0x1a0>
ffc0e944 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
ffc0e944: 7d 80 00 26 mfcr r12
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
ffc0e948: 2e 04 00 00 cmpwi cr4,r4,0
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
ffc0e94c: 94 21 ff d8 stwu r1,-40(r1)
ffc0e950: 7c 08 02 a6 mflr r0
ffc0e954: 93 e1 00 24 stw r31,36(r1)
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
ffc0e958: 7c 9f 23 78 mr r31,r4
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
ffc0e95c: 90 01 00 2c stw r0,44(r1)
ffc0e960: 91 81 00 20 stw r12,32(r1)
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
ffc0e964: 41 92 00 18 beq- cr4,ffc0e97c <rtems_task_set_priority+0x38>
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 ) );
ffc0e968: 3d 20 00 00 lis r9,0
ffc0e96c: 89 29 27 44 lbz r9,10052(r9)
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
ffc0e970: 38 00 00 13 li r0,19
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
ffc0e974: 7f 84 48 40 cmplw cr7,r4,r9
ffc0e978: 41 9d 00 68 bgt- cr7,ffc0e9e0 <rtems_task_set_priority+0x9c>
if ( !old_priority )
ffc0e97c: 2f 85 00 00 cmpwi cr7,r5,0
return RTEMS_INVALID_ADDRESS;
ffc0e980: 38 00 00 09 li r0,9
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
ffc0e984: 41 9e 00 5c beq- cr7,ffc0e9e0 <rtems_task_set_priority+0x9c>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
ffc0e988: 38 81 00 08 addi r4,r1,8
ffc0e98c: 90 a1 00 18 stw r5,24(r1)
ffc0e990: 48 00 2e 65 bl ffc117f4 <_Thread_Get>
switch ( location ) {
ffc0e994: 80 01 00 08 lwz r0,8(r1)
ffc0e998: 80 a1 00 18 lwz r5,24(r1)
ffc0e99c: 2f 80 00 00 cmpwi cr7,r0,0
ffc0e9a0: 40 9e 00 60 bne- cr7,ffc0ea00 <rtems_task_set_priority+0xbc>
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
ffc0e9a4: 80 03 00 14 lwz r0,20(r3)
ffc0e9a8: 90 05 00 00 stw r0,0(r5)
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
ffc0e9ac: 41 92 00 2c beq- cr4,ffc0e9d8 <rtems_task_set_priority+0x94>
the_thread->real_priority = new_priority;
if ( the_thread->resource_count == 0 ||
ffc0e9b0: 80 03 00 1c lwz r0,28(r3)
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;
ffc0e9b4: 93 e3 00 18 stw r31,24(r3)
if ( the_thread->resource_count == 0 ||
ffc0e9b8: 2f 80 00 00 cmpwi cr7,r0,0
ffc0e9bc: 41 9e 00 10 beq- cr7,ffc0e9cc <rtems_task_set_priority+0x88>
ffc0e9c0: 80 03 00 14 lwz r0,20(r3)
ffc0e9c4: 7f 9f 00 40 cmplw cr7,r31,r0
ffc0e9c8: 40 9c 00 10 bge- cr7,ffc0e9d8 <rtems_task_set_priority+0x94><== ALWAYS TAKEN
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
ffc0e9cc: 7f e4 fb 78 mr r4,r31
ffc0e9d0: 38 a0 00 00 li r5,0
ffc0e9d4: 48 00 27 c1 bl ffc11194 <_Thread_Change_priority>
}
_Thread_Enable_dispatch();
ffc0e9d8: 48 00 2d e1 bl ffc117b8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
ffc0e9dc: 38 00 00 00 li r0,0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
ffc0e9e0: 7c 03 03 78 mr r3,r0
ffc0e9e4: 80 01 00 2c lwz r0,44(r1)
ffc0e9e8: 81 81 00 20 lwz r12,32(r1)
ffc0e9ec: 7c 08 03 a6 mtlr r0
ffc0e9f0: 83 e1 00 24 lwz r31,36(r1)
ffc0e9f4: 7d 80 81 20 mtcrf 8,r12
ffc0e9f8: 38 21 00 28 addi r1,r1,40
ffc0e9fc: 4e 80 00 20 blr
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
ffc0ea00: 38 00 00 04 li r0,4
}
ffc0ea04: 81 81 00 20 lwz r12,32(r1)
ffc0ea08: 7c 03 03 78 mr r3,r0
ffc0ea0c: 80 01 00 2c lwz r0,44(r1)
ffc0ea10: 83 e1 00 24 lwz r31,36(r1)
ffc0ea14: 7d 80 81 20 mtcrf 8,r12
ffc0ea18: 7c 08 03 a6 mtlr r0
ffc0ea1c: 38 21 00 28 addi r1,r1,40
ffc0ea20: 4e 80 00 20 blr
ffc0a574 <rtems_task_variable_delete>:
rtems_status_code rtems_task_variable_delete(
rtems_id tid,
void **ptr
)
{
ffc0a574: 94 21 ff e0 stwu r1,-32(r1)
ffc0a578: 7c 08 02 a6 mflr r0
ffc0a57c: 93 e1 00 1c stw r31,28(r1)
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
ffc0a580: 7c 9f 23 79 mr. r31,r4
rtems_status_code rtems_task_variable_delete(
rtems_id tid,
void **ptr
)
{
ffc0a584: 90 01 00 24 stw r0,36(r1)
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
ffc0a588: 38 00 00 09 li r0,9
{
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
ffc0a58c: 41 82 00 58 beq- ffc0a5e4 <rtems_task_variable_delete+0x70>
return RTEMS_INVALID_ADDRESS;
prev = NULL;
the_thread = _Thread_Get (tid, &location);
ffc0a590: 38 81 00 08 addi r4,r1,8
ffc0a594: 48 00 2b f9 bl ffc0d18c <_Thread_Get>
switch (location) {
ffc0a598: 80 01 00 08 lwz r0,8(r1)
ffc0a59c: 2f 80 00 00 cmpwi cr7,r0,0
ffc0a5a0: 40 9e 00 5c bne- cr7,ffc0a5fc <rtems_task_variable_delete+0x88>
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
ffc0a5a4: 81 23 01 3c lwz r9,316(r3)
while (tvp) {
ffc0a5a8: 2f 89 00 00 cmpwi cr7,r9,0
ffc0a5ac: 41 9e 00 30 beq- cr7,ffc0a5dc <rtems_task_variable_delete+0x68>
if (tvp->ptr == ptr) {
ffc0a5b0: 80 09 00 04 lwz r0,4(r9)
ffc0a5b4: 7f 80 f8 00 cmpw cr7,r0,r31
ffc0a5b8: 40 be 00 18 bne+ cr7,ffc0a5d0 <rtems_task_variable_delete+0x5c>
ffc0a5bc: 48 00 00 74 b ffc0a630 <rtems_task_variable_delete+0xbc>
ffc0a5c0: 80 04 00 04 lwz r0,4(r4)
ffc0a5c4: 7f 80 f8 00 cmpw cr7,r0,r31
ffc0a5c8: 41 9e 00 50 beq- cr7,ffc0a618 <rtems_task_variable_delete+0xa4>
ffc0a5cc: 7c 89 23 78 mr r9,r4
_RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
ffc0a5d0: 80 89 00 00 lwz r4,0(r9)
the_thread = _Thread_Get (tid, &location);
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
ffc0a5d4: 2f 84 00 00 cmpwi cr7,r4,0
ffc0a5d8: 40 9e ff e8 bne+ cr7,ffc0a5c0 <rtems_task_variable_delete+0x4c><== ALWAYS TAKEN
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
ffc0a5dc: 48 00 2b 75 bl ffc0d150 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
ffc0a5e0: 38 00 00 09 li r0,9
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
ffc0a5e4: 7c 03 03 78 mr r3,r0
ffc0a5e8: 80 01 00 24 lwz r0,36(r1)
ffc0a5ec: 83 e1 00 1c lwz r31,28(r1)
ffc0a5f0: 38 21 00 20 addi r1,r1,32
ffc0a5f4: 7c 08 03 a6 mtlr r0
ffc0a5f8: 4e 80 00 20 blr
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
ffc0a5fc: 38 00 00 04 li r0,4
}
ffc0a600: 83 e1 00 1c lwz r31,28(r1)
ffc0a604: 7c 03 03 78 mr r3,r0
ffc0a608: 80 01 00 24 lwz r0,36(r1)
ffc0a60c: 38 21 00 20 addi r1,r1,32
ffc0a610: 7c 08 03 a6 mtlr r0
ffc0a614: 4e 80 00 20 blr
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
ffc0a618: 80 04 00 00 lwz r0,0(r4)
ffc0a61c: 90 09 00 00 stw r0,0(r9)
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
_RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
ffc0a620: 48 00 00 d9 bl ffc0a6f8 <_RTEMS_Tasks_Invoke_task_variable_dtor>
_Thread_Enable_dispatch();
ffc0a624: 48 00 2b 2d bl ffc0d150 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
ffc0a628: 38 00 00 00 li r0,0
ffc0a62c: 4b ff ff b8 b ffc0a5e4 <rtems_task_variable_delete+0x70>
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
ffc0a630: 80 09 00 00 lwz r0,0(r9)
ffc0a634: 7d 24 4b 78 mr r4,r9
ffc0a638: 90 03 01 3c stw r0,316(r3)
ffc0a63c: 4b ff ff e4 b ffc0a620 <rtems_task_variable_delete+0xac>
ffc0a640 <rtems_task_variable_get>:
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
ffc0a640: 94 21 ff d8 stwu r1,-40(r1)
ffc0a644: 7c 08 02 a6 mflr r0
ffc0a648: 93 e1 00 24 stw r31,36(r1)
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
ffc0a64c: 7c 9f 23 79 mr. r31,r4
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
ffc0a650: 90 01 00 2c stw r0,44(r1)
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
ffc0a654: 38 00 00 09 li r0,9
{
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
ffc0a658: 41 82 00 60 beq- ffc0a6b8 <rtems_task_variable_get+0x78>
return RTEMS_INVALID_ADDRESS;
if ( !result )
ffc0a65c: 2f 85 00 00 cmpwi cr7,r5,0
ffc0a660: 41 9e 00 58 beq- cr7,ffc0a6b8 <rtems_task_variable_get+0x78>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
ffc0a664: 38 81 00 08 addi r4,r1,8
ffc0a668: 90 a1 00 18 stw r5,24(r1)
ffc0a66c: 48 00 2b 21 bl ffc0d18c <_Thread_Get>
switch (location) {
ffc0a670: 80 01 00 08 lwz r0,8(r1)
ffc0a674: 80 a1 00 18 lwz r5,24(r1)
ffc0a678: 2f 80 00 00 cmpwi cr7,r0,0
ffc0a67c: 40 9e 00 54 bne- cr7,ffc0a6d0 <rtems_task_variable_get+0x90>
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
ffc0a680: 81 23 01 3c lwz r9,316(r3)
while (tvp) {
ffc0a684: 2f 89 00 00 cmpwi cr7,r9,0
ffc0a688: 40 be 00 14 bne+ cr7,ffc0a69c <rtems_task_variable_get+0x5c>
ffc0a68c: 48 00 00 60 b ffc0a6ec <rtems_task_variable_get+0xac>
*/
*result = tvp->tval;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
ffc0a690: 81 29 00 00 lwz r9,0(r9)
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
while (tvp) {
ffc0a694: 2f 89 00 00 cmpwi cr7,r9,0
ffc0a698: 41 9e 00 54 beq- cr7,ffc0a6ec <rtems_task_variable_get+0xac><== NEVER TAKEN
if (tvp->ptr == ptr) {
ffc0a69c: 80 09 00 04 lwz r0,4(r9)
ffc0a6a0: 7f 80 f8 00 cmpw cr7,r0,r31
ffc0a6a4: 40 9e ff ec bne+ cr7,ffc0a690 <rtems_task_variable_get+0x50>
/*
* Should this return the current (i.e not the
* saved) value if `tid' is the current task?
*/
*result = tvp->tval;
ffc0a6a8: 80 09 00 0c lwz r0,12(r9)
ffc0a6ac: 90 05 00 00 stw r0,0(r5)
_Thread_Enable_dispatch();
ffc0a6b0: 48 00 2a a1 bl ffc0d150 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
ffc0a6b4: 38 00 00 00 li r0,0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
ffc0a6b8: 7c 03 03 78 mr r3,r0
ffc0a6bc: 80 01 00 2c lwz r0,44(r1)
ffc0a6c0: 83 e1 00 24 lwz r31,36(r1)
ffc0a6c4: 38 21 00 28 addi r1,r1,40
ffc0a6c8: 7c 08 03 a6 mtlr r0
ffc0a6cc: 4e 80 00 20 blr
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
ffc0a6d0: 38 00 00 04 li r0,4
}
ffc0a6d4: 83 e1 00 24 lwz r31,36(r1)
ffc0a6d8: 7c 03 03 78 mr r3,r0
ffc0a6dc: 80 01 00 2c lwz r0,44(r1)
ffc0a6e0: 38 21 00 28 addi r1,r1,40
ffc0a6e4: 7c 08 03 a6 mtlr r0
ffc0a6e8: 4e 80 00 20 blr
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
ffc0a6ec: 48 00 2a 65 bl ffc0d150 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
ffc0a6f0: 38 00 00 09 li r0,9
ffc0a6f4: 4b ff ff c4 b ffc0a6b8 <rtems_task_variable_get+0x78>
ffc08398 <rtems_termios_baud_to_index>:
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
ffc08398: 2f 83 00 09 cmpwi cr7,r3,9
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;
ffc0839c: 38 00 00 09 li r0,9
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
ffc083a0: 41 9e 00 44 beq- cr7,ffc083e4 <rtems_termios_baud_to_index+0x4c>
ffc083a4: 40 9d 00 48 ble- cr7,ffc083ec <rtems_termios_baud_to_index+0x54>
ffc083a8: 2f 83 00 0e cmpwi cr7,r3,14
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;
ffc083ac: 38 00 00 0e li r0,14
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
ffc083b0: 41 9e 00 34 beq- cr7,ffc083e4 <rtems_termios_baud_to_index+0x4c>
ffc083b4: 40 9d 00 78 ble- cr7,ffc0842c <rtems_termios_baud_to_index+0x94>
ffc083b8: 2f 83 10 02 cmpwi cr7,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;
ffc083bc: 38 00 00 11 li r0,17
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
ffc083c0: 41 9e 00 24 beq- cr7,ffc083e4 <rtems_termios_baud_to_index+0x4c>
ffc083c4: 40 9d 00 d4 ble- cr7,ffc08498 <rtems_termios_baud_to_index+0x100>
ffc083c8: 2f 83 10 03 cmpwi cr7,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;
ffc083cc: 38 00 00 12 li r0,18
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
ffc083d0: 41 9e 00 14 beq- cr7,ffc083e4 <rtems_termios_baud_to_index+0x4c>
ffc083d4: 2f 83 10 04 cmpwi cr7,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;
ffc083d8: 38 00 00 13 li r0,19
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
ffc083dc: 41 9e 00 08 beq- cr7,ffc083e4 <rtems_termios_baud_to_index+0x4c><== 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;
ffc083e0: 38 00 ff ff li r0,-1
}
return baud_index;
}
ffc083e4: 7c 03 03 78 mr r3,r0
ffc083e8: 4e 80 00 20 blr
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
ffc083ec: 2f 83 00 04 cmpwi cr7,r3,4
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;
ffc083f0: 38 00 00 04 li r0,4
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
ffc083f4: 41 be ff f0 beq- cr7,ffc083e4 <rtems_termios_baud_to_index+0x4c>
ffc083f8: 41 9d 00 64 bgt- cr7,ffc0845c <rtems_termios_baud_to_index+0xc4>
ffc083fc: 2f 83 00 01 cmpwi cr7,r3,1
case B0: baud_index = 0; break;
case B50: baud_index = 1; break;
ffc08400: 38 00 00 01 li r0,1
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
ffc08404: 41 be ff e0 beq- cr7,ffc083e4 <rtems_termios_baud_to_index+0x4c>
ffc08408: 40 9d 00 ac ble- cr7,ffc084b4 <rtems_termios_baud_to_index+0x11c>
ffc0840c: 2f 83 00 02 cmpwi cr7,r3,2
case B0: baud_index = 0; break;
case B50: baud_index = 1; break;
case B75: baud_index = 2; break;
ffc08410: 38 00 00 02 li r0,2
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
ffc08414: 41 be ff d0 beq- cr7,ffc083e4 <rtems_termios_baud_to_index+0x4c>
ffc08418: 2f 83 00 03 cmpwi cr7,r3,3
case B0: baud_index = 0; break;
case B50: baud_index = 1; break;
case B75: baud_index = 2; break;
case B110: baud_index = 3; break;
ffc0841c: 38 00 00 03 li r0,3
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
ffc08420: 41 be ff c4 beq- cr7,ffc083e4 <rtems_termios_baud_to_index+0x4c><== 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;
ffc08424: 38 00 ff ff li r0,-1 <== NOT EXECUTED
ffc08428: 4b ff ff bc b ffc083e4 <rtems_termios_baud_to_index+0x4c><== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
ffc0842c: 2f 83 00 0b cmpwi cr7,r3,11
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;
ffc08430: 38 00 00 0b li r0,11
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
ffc08434: 41 be ff b0 beq- cr7,ffc083e4 <rtems_termios_baud_to_index+0x4c>
ffc08438: 41 9c 00 58 blt- cr7,ffc08490 <rtems_termios_baud_to_index+0xf8>
ffc0843c: 2f 83 00 0c cmpwi cr7,r3,12
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;
ffc08440: 38 00 00 0c li r0,12
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
ffc08444: 41 be ff a0 beq- cr7,ffc083e4 <rtems_termios_baud_to_index+0x4c>
ffc08448: 2f 83 00 0d cmpwi cr7,r3,13
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;
ffc0844c: 38 00 00 0d li r0,13
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
ffc08450: 41 be ff 94 beq- cr7,ffc083e4 <rtems_termios_baud_to_index+0x4c><== 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;
ffc08454: 38 00 ff ff li r0,-1 <== NOT EXECUTED
ffc08458: 4b ff ff 8c b ffc083e4 <rtems_termios_baud_to_index+0x4c><== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
ffc0845c: 2f 83 00 06 cmpwi cr7,r3,6
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;
ffc08460: 38 00 00 06 li r0,6
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
ffc08464: 41 be ff 80 beq- cr7,ffc083e4 <rtems_termios_baud_to_index+0x4c>
ffc08468: 41 9c 00 20 blt- cr7,ffc08488 <rtems_termios_baud_to_index+0xf0>
ffc0846c: 2f 83 00 07 cmpwi cr7,r3,7
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;
ffc08470: 38 00 00 07 li r0,7
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
ffc08474: 41 be ff 70 beq- cr7,ffc083e4 <rtems_termios_baud_to_index+0x4c>
ffc08478: 2f 83 00 08 cmpwi cr7,r3,8
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;
ffc0847c: 38 00 00 08 li r0,8
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
ffc08480: 40 9e ff 60 bne+ cr7,ffc083e0 <rtems_termios_baud_to_index+0x48><== NEVER TAKEN
ffc08484: 4b ff ff 60 b ffc083e4 <rtems_termios_baud_to_index+0x4c>
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;
ffc08488: 38 00 00 05 li r0,5
ffc0848c: 4b ff ff 58 b ffc083e4 <rtems_termios_baud_to_index+0x4c>
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;
ffc08490: 38 00 00 0a li r0,10
ffc08494: 4b ff ff 50 b ffc083e4 <rtems_termios_baud_to_index+0x4c>
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
ffc08498: 2f 83 00 0f cmpwi cr7,r3,15
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;
ffc0849c: 38 00 00 0f li r0,15
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
ffc084a0: 41 be ff 44 beq- cr7,ffc083e4 <rtems_termios_baud_to_index+0x4c>
ffc084a4: 2f 83 10 01 cmpwi cr7,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;
ffc084a8: 38 00 00 10 li r0,16
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
ffc084ac: 40 9e ff 34 bne+ cr7,ffc083e0 <rtems_termios_baud_to_index+0x48><== NEVER TAKEN
ffc084b0: 4b ff ff 34 b ffc083e4 <rtems_termios_baud_to_index+0x4c>
ffc084b4: 2f 83 00 00 cmpwi cr7,r3,0
case B0: baud_index = 0; break;
ffc084b8: 38 00 00 00 li r0,0
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
ffc084bc: 41 be ff 28 beq- cr7,ffc083e4 <rtems_termios_baud_to_index+0x4c>
ffc084c0: 4b ff ff 20 b ffc083e0 <rtems_termios_baud_to_index+0x48>
ffc06aa0 <rtems_termios_close>:
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
ffc06aa0: 94 21 ff e8 stwu r1,-24(r1)
ffc06aa4: 7c 08 02 a6 mflr r0
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain(
ffc06aa8: 38 80 00 00 li r4,0
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
ffc06aac: 90 01 00 1c stw r0,28(r1)
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain(
ffc06ab0: 38 a0 00 00 li r5,0
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
ffc06ab4: 93 c1 00 10 stw r30,16(r1)
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain(
ffc06ab8: 3f c0 00 00 lis r30,0
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
ffc06abc: 81 23 00 00 lwz r9,0(r3)
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
ffc06ac0: 93 a1 00 0c stw r29,12(r1)
ffc06ac4: 7c 7d 1b 78 mr r29,r3
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain(
ffc06ac8: 80 7e 27 fc lwz r3,10236(r30)
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
ffc06acc: 93 e1 00 14 stw r31,20(r1)
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
ffc06ad0: 83 e9 00 38 lwz r31,56(r9)
rtems_status_code sc;
sc = rtems_semaphore_obtain(
ffc06ad4: 48 00 29 05 bl ffc093d8 <rtems_semaphore_obtain>
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc06ad8: 2f 83 00 00 cmpwi cr7,r3,0
ffc06adc: 40 9e 01 b0 bne- cr7,ffc06c8c <rtems_termios_close+0x1ec><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
ffc06ae0: 81 3f 00 08 lwz r9,8(r31)
ffc06ae4: 38 09 ff ff addi r0,r9,-1
ffc06ae8: 2f 80 00 00 cmpwi cr7,r0,0
ffc06aec: 90 1f 00 08 stw r0,8(r31)
ffc06af0: 40 9e 00 d0 bne- cr7,ffc06bc0 <rtems_termios_close+0x120>
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
ffc06af4: 80 1f 00 cc lwz r0,204(r31)
ffc06af8: 3d 20 00 00 lis r9,0
ffc06afc: 39 29 28 f0 addi r9,r9,10480
ffc06b00: 54 00 28 34 rlwinm r0,r0,5,0,26
ffc06b04: 7d 29 02 14 add r9,r9,r0
ffc06b08: 80 09 00 04 lwz r0,4(r9)
ffc06b0c: 2f 80 00 00 cmpwi cr7,r0,0
ffc06b10: 41 9e 01 1c beq- cr7,ffc06c2c <rtems_termios_close+0x18c>
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
ffc06b14: 7c 09 03 a6 mtctr r0
ffc06b18: 7f e3 fb 78 mr r3,r31
ffc06b1c: 4e 80 04 21 bctrl
}
drainOutput (tty);
rtems_semaphore_release (tty->osem);
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
ffc06b20: 80 1f 00 b4 lwz r0,180(r31)
ffc06b24: 2f 80 00 02 cmpwi cr7,r0,2
ffc06b28: 41 9e 01 3c beq- cr7,ffc06c64 <rtems_termios_close+0x1c4><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
ffc06b2c: 80 1f 00 9c lwz r0,156(r31)
ffc06b30: 2f 80 00 00 cmpwi cr7,r0,0
ffc06b34: 41 9e 00 18 beq- cr7,ffc06b4c <rtems_termios_close+0xac><== ALWAYS TAKEN
(*tty->device.lastClose)(tty->major, tty->minor, arg);
ffc06b38: 80 7f 00 0c lwz r3,12(r31) <== NOT EXECUTED
ffc06b3c: 7f a5 eb 78 mr r5,r29 <== NOT EXECUTED
ffc06b40: 80 9f 00 10 lwz r4,16(r31) <== NOT EXECUTED
ffc06b44: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc06b48: 4e 80 04 21 bctrl <== NOT EXECUTED
if (tty->forw == NULL) {
ffc06b4c: 81 3f 00 00 lwz r9,0(r31)
ffc06b50: 2f 89 00 00 cmpwi cr7,r9,0
ffc06b54: 41 9e 00 b8 beq- cr7,ffc06c0c <rtems_termios_close+0x16c>
rtems_termios_ttyTail = tty->back;
if ( rtems_termios_ttyTail != NULL ) {
rtems_termios_ttyTail->forw = NULL;
}
} else {
tty->forw->back = tty->back;
ffc06b58: 80 1f 00 04 lwz r0,4(r31)
ffc06b5c: 90 09 00 04 stw r0,4(r9)
ffc06b60: 81 7f 00 04 lwz r11,4(r31)
}
if (tty->back == NULL) {
ffc06b64: 2f 0b 00 00 cmpwi cr6,r11,0
ffc06b68: 41 9a 00 8c beq- cr6,ffc06bf4 <rtems_termios_close+0x154><== ALWAYS TAKEN
rtems_termios_ttyHead = tty->forw;
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
}
} else {
tty->back->forw = tty->forw;
ffc06b6c: 91 2b 00 00 stw r9,0(r11) <== NOT EXECUTED
}
rtems_semaphore_delete (tty->isem);
ffc06b70: 80 7f 00 14 lwz r3,20(r31)
ffc06b74: 48 00 27 89 bl ffc092fc <rtems_semaphore_delete>
rtems_semaphore_delete (tty->osem);
ffc06b78: 80 7f 00 18 lwz r3,24(r31)
ffc06b7c: 48 00 27 81 bl ffc092fc <rtems_semaphore_delete>
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
ffc06b80: 80 7f 00 8c lwz r3,140(r31)
ffc06b84: 48 00 27 79 bl ffc092fc <rtems_semaphore_delete>
if ((tty->device.pollRead == NULL) ||
ffc06b88: 80 1f 00 a0 lwz r0,160(r31)
ffc06b8c: 2f 80 00 00 cmpwi cr7,r0,0
ffc06b90: 41 9e 00 58 beq- cr7,ffc06be8 <rtems_termios_close+0x148>
ffc06b94: 80 1f 00 b4 lwz r0,180(r31)
ffc06b98: 2f 80 00 02 cmpwi cr7,r0,2
ffc06b9c: 41 9e 00 4c beq- cr7,ffc06be8 <rtems_termios_close+0x148>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
free (tty->rawInBuf.theBuf);
ffc06ba0: 80 7f 00 58 lwz r3,88(r31)
ffc06ba4: 4b ff e5 f9 bl ffc0519c <free>
free (tty->rawOutBuf.theBuf);
ffc06ba8: 80 7f 00 7c lwz r3,124(r31)
ffc06bac: 4b ff e5 f1 bl ffc0519c <free>
free (tty->cbuf);
ffc06bb0: 80 7f 00 1c lwz r3,28(r31)
ffc06bb4: 4b ff e5 e9 bl ffc0519c <free>
free (tty);
ffc06bb8: 7f e3 fb 78 mr r3,r31
ffc06bbc: 4b ff e5 e1 bl ffc0519c <free>
}
rtems_semaphore_release (rtems_termios_ttyMutex);
ffc06bc0: 80 7e 27 fc lwz r3,10236(r30)
ffc06bc4: 48 00 29 a1 bl ffc09564 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
}
ffc06bc8: 80 01 00 1c lwz r0,28(r1)
ffc06bcc: 38 60 00 00 li r3,0
ffc06bd0: 83 a1 00 0c lwz r29,12(r1)
ffc06bd4: 7c 08 03 a6 mtlr r0
ffc06bd8: 83 c1 00 10 lwz r30,16(r1)
ffc06bdc: 83 e1 00 14 lwz r31,20(r1)
ffc06be0: 38 21 00 18 addi r1,r1,24
ffc06be4: 4e 80 00 20 blr
rtems_semaphore_delete (tty->isem);
rtems_semaphore_delete (tty->osem);
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
ffc06be8: 80 7f 00 68 lwz r3,104(r31)
ffc06bec: 48 00 27 11 bl ffc092fc <rtems_semaphore_delete>
ffc06bf0: 4b ff ff b0 b ffc06ba0 <rtems_termios_close+0x100>
} else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
ffc06bf4: 3d 60 00 00 lis r11,0
ffc06bf8: 91 2b 28 04 stw r9,10244(r11)
if ( rtems_termios_ttyHead != NULL ) {
ffc06bfc: 41 be ff 74 beq- cr7,ffc06b70 <rtems_termios_close+0xd0>
rtems_termios_ttyHead->back = NULL;
ffc06c00: 38 00 00 00 li r0,0
ffc06c04: 90 09 00 04 stw r0,4(r9)
ffc06c08: 4b ff ff 68 b ffc06b70 <rtems_termios_close+0xd0>
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
(*tty->device.lastClose)(tty->major, tty->minor, arg);
if (tty->forw == NULL) {
rtems_termios_ttyTail = tty->back;
ffc06c0c: 81 7f 00 04 lwz r11,4(r31)
ffc06c10: 3d 40 00 00 lis r10,0
if ( rtems_termios_ttyTail != NULL ) {
ffc06c14: 2f 0b 00 00 cmpwi cr6,r11,0
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
(*tty->device.lastClose)(tty->major, tty->minor, arg);
if (tty->forw == NULL) {
rtems_termios_ttyTail = tty->back;
ffc06c18: 91 6a 28 00 stw r11,10240(r10)
if ( rtems_termios_ttyTail != NULL ) {
ffc06c1c: 41 ba ff d8 beq- cr6,ffc06bf4 <rtems_termios_close+0x154><== ALWAYS TAKEN
rtems_termios_ttyTail->forw = NULL;
ffc06c20: 91 2b 00 00 stw r9,0(r11) <== NOT EXECUTED
ffc06c24: 81 3f 00 00 lwz r9,0(r31) <== NOT EXECUTED
ffc06c28: 4b ff ff 44 b ffc06b6c <rtems_termios_close+0xcc> <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
} else {
/*
* default: just flush output buffer
*/
sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
ffc06c2c: 80 7f 00 18 lwz r3,24(r31)
ffc06c30: 38 80 00 00 li r4,0
ffc06c34: 38 a0 00 00 li r5,0
ffc06c38: 48 00 27 a1 bl ffc093d8 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
ffc06c3c: 2f 83 00 00 cmpwi cr7,r3,0
ffc06c40: 40 9e 00 4c bne- cr7,ffc06c8c <rtems_termios_close+0x1ec><== NEVER TAKEN
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
ffc06c44: 80 1f 00 b4 lwz r0,180(r31)
ffc06c48: 2f 80 00 00 cmpwi cr7,r0,0
ffc06c4c: 40 9e 00 44 bne- cr7,ffc06c90 <rtems_termios_close+0x1f0>
sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
rtems_fatal_error_occurred (sc);
}
drainOutput (tty);
rtems_semaphore_release (tty->osem);
ffc06c50: 80 7f 00 18 lwz r3,24(r31)
ffc06c54: 48 00 29 11 bl ffc09564 <rtems_semaphore_release>
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
ffc06c58: 80 1f 00 b4 lwz r0,180(r31)
ffc06c5c: 2f 80 00 02 cmpwi cr7,r0,2
ffc06c60: 40 9e fe cc bne+ cr7,ffc06b2c <rtems_termios_close+0x8c>
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
ffc06c64: 80 7f 00 c4 lwz r3,196(r31)
ffc06c68: 38 80 00 01 li r4,1
ffc06c6c: 48 00 22 19 bl ffc08e84 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
ffc06c70: 2f 83 00 00 cmpwi cr7,r3,0
ffc06c74: 40 9e 00 18 bne- cr7,ffc06c8c <rtems_termios_close+0x1ec><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
ffc06c78: 80 7f 00 c8 lwz r3,200(r31)
ffc06c7c: 38 80 00 01 li r4,1
ffc06c80: 48 00 22 05 bl ffc08e84 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
ffc06c84: 2f 83 00 00 cmpwi cr7,r3,0
ffc06c88: 41 9e fe a4 beq+ cr7,ffc06b2c <rtems_termios_close+0x8c><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
ffc06c8c: 48 00 30 b5 bl ffc09d40 <rtems_fatal_error_occurred> <== NOT EXECUTED
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
ffc06c90: 7f e3 fb 78 mr r3,r31
ffc06c94: 4b ff f8 d5 bl ffc06568 <drainOutput.part.0>
ffc06c98: 4b ff ff b8 b ffc06c50 <rtems_termios_close+0x1b0>
ffc086b4 <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)
{
ffc086b4: 94 21 ff f8 stwu r1,-8(r1)
ffc086b8: 7c 08 02 a6 mflr r0
ffc086bc: 90 01 00 0c stw r0,12(r1)
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
ffc086c0: 81 63 00 b4 lwz r11,180(r3)
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
ffc086c4: 80 03 00 90 lwz r0,144(r3)
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
ffc086c8: 2f 8b 00 02 cmpwi cr7,r11,2
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
ffc086cc: 7c 00 22 14 add r0,r0,r4
ffc086d0: 90 03 00 90 stw r0,144(r3)
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
ffc086d4: 41 9e 00 4c beq- cr7,ffc08720 <rtems_termios_dequeue_characters+0x6c>
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
return 0; /* nothing to output in IRQ... */
}
if (tty->t_line == PPPDISC ) {
ffc086d8: 80 03 00 cc lwz r0,204(r3)
ffc086dc: 2f 80 00 05 cmpwi cr7,r0,5
ffc086e0: 41 9e 00 14 beq- cr7,ffc086f4 <rtems_termios_dequeue_characters+0x40>
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
}
ffc086e4: 80 01 00 0c lwz r0,12(r1)
ffc086e8: 38 21 00 08 addi r1,r1,8
ffc086ec: 7c 08 03 a6 mtlr r0
rtems_termios_linesw[tty->t_line].l_start(tty);
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
ffc086f0: 4b ff fc e4 b ffc083d4 <rtems_termios_refill_transmitter>
if (tty->t_line == PPPDISC ) {
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
ffc086f4: 3d 20 00 00 lis r9,0
ffc086f8: 80 09 29 a4 lwz r0,10660(r9)
ffc086fc: 2f 80 00 00 cmpwi cr7,r0,0
ffc08700: 41 9e 00 0c beq- cr7,ffc0870c <rtems_termios_dequeue_characters+0x58><== NEVER TAKEN
rtems_termios_linesw[tty->t_line].l_start(tty);
ffc08704: 7c 09 03 a6 mtctr r0
ffc08708: 4e 80 04 21 bctrl
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
}
ffc0870c: 80 01 00 0c lwz r0,12(r1)
ffc08710: 38 60 00 00 li r3,0
ffc08714: 38 21 00 08 addi r1,r1,8
ffc08718: 7c 08 03 a6 mtlr r0
ffc0871c: 4e 80 00 20 blr
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
ffc08720: 80 63 00 c8 lwz r3,200(r3)
ffc08724: 38 80 00 02 li r4,2
ffc08728: 48 00 07 5d bl ffc08e84 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
ffc0872c: 2f 83 00 00 cmpwi cr7,r3,0
ffc08730: 41 9e ff dc beq+ cr7,ffc0870c <rtems_termios_dequeue_characters+0x58><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
ffc08734: 48 00 16 0d bl ffc09d40 <rtems_fatal_error_occurred> <== NOT EXECUTED
ffc07f9c <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, const char *buf, int len)
{
ffc07f9c: 94 21 ff c8 stwu r1,-56(r1)
ffc07fa0: 7c 08 02 a6 mflr r0
ffc07fa4: 90 01 00 3c stw r0,60(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) {
ffc07fa8: 81 23 00 cc lwz r9,204(r3)
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
{
ffc07fac: 93 c1 00 30 stw r30,48(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) {
ffc07fb0: 3f c0 00 00 lis r30,0
ffc07fb4: 3b de 28 f0 addi r30,r30,10480
ffc07fb8: 55 29 28 34 rlwinm r9,r9,5,0,26
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
{
ffc07fbc: 93 e1 00 34 stw r31,52(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) {
ffc07fc0: 7d 3e 4a 14 add r9,r30,r9
ffc07fc4: 80 09 00 10 lwz r0,16(r9)
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
{
ffc07fc8: 7c 7f 1b 78 mr r31,r3
ffc07fcc: 92 c1 00 10 stw r22,16(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) {
ffc07fd0: 2f 80 00 00 cmpwi cr7,r0,0
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
{
ffc07fd4: 92 e1 00 14 stw r23,20(r1)
ffc07fd8: 93 01 00 18 stw r24,24(r1)
ffc07fdc: 93 21 00 1c stw r25,28(r1)
ffc07fe0: 93 41 00 20 stw r26,32(r1)
ffc07fe4: 93 61 00 24 stw r27,36(r1)
ffc07fe8: 93 81 00 28 stw r28,40(r1)
ffc07fec: 93 a1 00 2c stw r29,44(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) {
ffc07ff0: 41 9e 00 b8 beq- cr7,ffc080a8 <rtems_termios_enqueue_raw_characters+0x10c>
while (len--) {
ffc07ff4: 2f 85 00 00 cmpwi cr7,r5,0
ffc07ff8: 41 9e 00 40 beq- cr7,ffc08038 <rtems_termios_enqueue_raw_characters+0x9c><== NEVER TAKEN
* NOTE: This routine runs in the context of the
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
ffc07ffc: 3b a4 ff ff addi r29,r4,-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--) {
ffc08000: 90 a1 00 08 stw r5,8(r1)
ffc08004: 48 00 00 14 b ffc08018 <rtems_termios_enqueue_raw_characters+0x7c>
ffc08008: 81 3f 00 cc lwz r9,204(r31)
ffc0800c: 55 29 28 34 rlwinm r9,r9,5,0,26
ffc08010: 7d 3e 4a 14 add r9,r30,r9
ffc08014: 80 09 00 10 lwz r0,16(r9)
c = *buf++;
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
ffc08018: 7c 09 03 a6 mtctr r0
ffc0801c: 8c 7d 00 01 lbzu r3,1(r29)
ffc08020: 7f e4 fb 78 mr r4,r31
ffc08024: 4e 80 04 21 bctrl
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--) {
ffc08028: 80 01 00 08 lwz r0,8(r1)
ffc0802c: 35 20 ff ff addic. r9,r0,-1
ffc08030: 91 21 00 08 stw r9,8(r1)
ffc08034: 40 82 ff d4 bne+ ffc08008 <rtems_termios_enqueue_raw_characters+0x6c>
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
ffc08038: 80 1f 00 e4 lwz r0,228(r31)
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
}
return 0;
ffc0803c: 3b 60 00 00 li r27,0
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
ffc08040: 2f 80 00 00 cmpwi cr7,r0,0
ffc08044: 40 9e 00 28 bne- cr7,ffc0806c <rtems_termios_enqueue_raw_characters+0xd0><== NEVER TAKEN
ffc08048: 80 1f 00 dc lwz r0,220(r31)
ffc0804c: 2f 80 00 00 cmpwi cr7,r0,0
ffc08050: 41 9e 00 1c beq- cr7,ffc0806c <rtems_termios_enqueue_raw_characters+0xd0>
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
ffc08054: 7c 09 03 a6 mtctr r0
ffc08058: 38 7f 00 30 addi r3,r31,48
ffc0805c: 80 9f 00 e0 lwz r4,224(r31)
ffc08060: 4e 80 04 21 bctrl
tty->tty_rcvwakeup = 1;
ffc08064: 38 00 00 01 li r0,1
ffc08068: 90 1f 00 e4 stw r0,228(r31)
}
tty->rawInBufDropped += dropped;
rtems_semaphore_release (tty->rawInBuf.Semaphore);
return dropped;
}
ffc0806c: 80 01 00 3c lwz r0,60(r1)
ffc08070: 7f 63 db 78 mr r3,r27
ffc08074: 82 c1 00 10 lwz r22,16(r1)
ffc08078: 7c 08 03 a6 mtlr r0
ffc0807c: 82 e1 00 14 lwz r23,20(r1)
ffc08080: 83 01 00 18 lwz r24,24(r1)
ffc08084: 83 21 00 1c lwz r25,28(r1)
ffc08088: 83 41 00 20 lwz r26,32(r1)
ffc0808c: 83 61 00 24 lwz r27,36(r1)
ffc08090: 83 81 00 28 lwz r28,40(r1)
ffc08094: 83 a1 00 2c lwz r29,44(r1)
ffc08098: 83 c1 00 30 lwz r30,48(r1)
ffc0809c: 83 e1 00 34 lwz r31,52(r1)
ffc080a0: 38 21 00 38 addi r1,r1,56
ffc080a4: 4e 80 00 20 blr
* NOTE: This routine runs in the context of the
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
ffc080a8: 3b c4 ff ff addi r30,r4,-1
ffc080ac: 7f 5e 2a 14 add r26,r30,r5
ffc080b0: 3b 20 00 00 li r25,0
ffc080b4: 3b 60 00 00 li r27,0
/*
* 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);
ffc080b8: 3a e3 00 30 addi r23,r3,48
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,
ffc080bc: 3a c3 00 4a addi r22,r3,74
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
ffc080c0: 7f 9e d0 00 cmpw cr7,r30,r26
ffc080c4: 41 9e 01 14 beq- cr7,ffc081d8 <rtems_termios_enqueue_raw_characters+0x23c>
c = *buf++;
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
ffc080c8: 80 1f 00 b8 lwz r0,184(r31)
}
return 0;
}
while (len--) {
c = *buf++;
ffc080cc: 8f 9e 00 01 lbzu r28,1(r30)
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
ffc080d0: 70 09 02 00 andi. r9,r0,512
ffc080d4: 41 82 00 1c beq- ffc080f0 <rtems_termios_enqueue_raw_characters+0x154>
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
ffc080d8: 88 1f 00 4a lbz r0,74(r31)
ffc080dc: 7f 80 e0 00 cmpw cr7,r0,r28
ffc080e0: 41 9e 01 48 beq- cr7,ffc08228 <rtems_termios_enqueue_raw_characters+0x28c>
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
ffc080e4: 88 1f 00 49 lbz r0,73(r31)
ffc080e8: 7f 80 e0 00 cmpw cr7,r0,r28
ffc080ec: 41 9e 01 c8 beq- cr7,ffc082b4 <rtems_termios_enqueue_raw_characters+0x318><== NEVER TAKEN
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
flow_rcv = true;
}
}
if (flow_rcv) {
ffc080f0: 2f 99 00 00 cmpwi cr7,r25,0
ffc080f4: 40 9e 01 50 bne- cr7,ffc08244 <rtems_termios_enqueue_raw_characters+0x2a8><== NEVER TAKEN
}
/* reenable interrupts */
rtems_interrupt_enable(level);
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
ffc080f8: 83 bf 00 60 lwz r29,96(r31)
ffc080fc: 81 3f 00 64 lwz r9,100(r31)
ffc08100: 38 1d 00 01 addi r0,r29,1
ffc08104: 7f a0 4b 96 divwu r29,r0,r9
ffc08108: 7f bd 49 d6 mullw r29,r29,r9
ffc0810c: 7f bd 00 50 subf r29,r29,r0
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc08110: 7f 00 00 a6 mfmsr r24
ffc08114: 7c 10 42 a6 mfsprg r0,0
ffc08118: 7f 00 00 78 andc r0,r24,r0
ffc0811c: 7c 00 01 24 mtmsr r0
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
ffc08120: 80 1f 00 5c lwz r0,92(r31)
ffc08124: 81 7f 00 64 lwz r11,100(r31)
% tty->rawInBuf.Size) > tty->highwater) &&
ffc08128: 81 3f 00 64 lwz r9,100(r31)
}
} 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)
ffc0812c: 7c 00 58 50 subf r0,r0,r11
ffc08130: 81 7f 00 c0 lwz r11,192(r31)
ffc08134: 7c 00 ea 14 add r0,r0,r29
% tty->rawInBuf.Size) > tty->highwater) &&
ffc08138: 7d 40 4b 96 divwu r10,r0,r9
ffc0813c: 7d 2a 49 d6 mullw r9,r10,r9
ffc08140: 7c 09 00 50 subf r0,r9,r0
}
} 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)
ffc08144: 7f 80 58 40 cmplw cr7,r0,r11
ffc08148: 40 9d 00 3c ble- cr7,ffc08184 <rtems_termios_enqueue_raw_characters+0x1e8><== ALWAYS TAKEN
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
ffc0814c: 80 1f 00 b8 lwz r0,184(r31) <== 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) &&
ffc08150: 70 09 00 01 andi. r9,r0,1 <== NOT EXECUTED
ffc08154: 40 82 00 30 bne- ffc08184 <rtems_termios_enqueue_raw_characters+0x1e8><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
ffc08158: 80 1f 00 b8 lwz r0,184(r31) <== NOT EXECUTED
ffc0815c: 60 00 00 01 ori r0,r0,1 <== NOT EXECUTED
ffc08160: 90 1f 00 b8 stw r0,184(r31) <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
ffc08164: 80 1f 00 b8 lwz r0,184(r31) <== NOT EXECUTED
ffc08168: 70 00 04 02 andi. r0,r0,1026 <== NOT EXECUTED
ffc0816c: 2f 80 04 00 cmpwi cr7,r0,1024 <== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
ffc08170: 80 1f 00 b8 lwz r0,184(r31) <== NOT EXECUTED
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))
ffc08174: 41 9e 01 64 beq- cr7,ffc082d8 <rtems_termios_enqueue_raw_characters+0x33c><== NOT EXECUTED
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
ffc08178: 70 00 01 04 andi. r0,r0,260 <== NOT EXECUTED
ffc0817c: 2f 80 01 00 cmpwi cr7,r0,256 <== NOT EXECUTED
ffc08180: 41 9e 01 94 beq- cr7,ffc08314 <rtems_termios_enqueue_raw_characters+0x378><== NOT EXECUTED
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc08184: 7f 00 01 24 mtmsr r24
}
/* reenable interrupts */
rtems_interrupt_enable(level);
if (newTail == tty->rawInBuf.Head) {
ffc08188: 80 1f 00 5c lwz r0,92(r31)
ffc0818c: 7f 80 e8 00 cmpw cr7,r0,r29
ffc08190: 41 9e 01 1c beq- cr7,ffc082ac <rtems_termios_enqueue_raw_characters+0x310><== NEVER TAKEN
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
ffc08194: 81 3f 00 58 lwz r9,88(r31)
ffc08198: 7f 89 e9 ae stbx r28,r9,r29
tty->rawInBuf.Tail = newTail;
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
ffc0819c: 80 1f 00 e4 lwz r0,228(r31)
if (newTail == tty->rawInBuf.Head) {
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
tty->rawInBuf.Tail = newTail;
ffc081a0: 93 bf 00 60 stw r29,96(r31)
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
ffc081a4: 2f 80 00 00 cmpwi cr7,r0,0
ffc081a8: 40 be ff 18 bne- cr7,ffc080c0 <rtems_termios_enqueue_raw_characters+0x124><== NEVER TAKEN
ffc081ac: 80 1f 00 dc lwz r0,220(r31)
ffc081b0: 2f 80 00 00 cmpwi cr7,r0,0
ffc081b4: 41 be ff 0c beq- cr7,ffc080c0 <rtems_termios_enqueue_raw_characters+0x124><== ALWAYS TAKEN
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
ffc081b8: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc081bc: 7e e3 bb 78 mr r3,r23 <== NOT EXECUTED
ffc081c0: 80 9f 00 e0 lwz r4,224(r31) <== NOT EXECUTED
ffc081c4: 4e 80 04 21 bctrl <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
ffc081c8: 7f 9e d0 00 cmpw cr7,r30,r26 <== NOT EXECUTED
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
ffc081cc: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc081d0: 90 1f 00 e4 stw r0,228(r31) <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
ffc081d4: 40 9e fe f4 bne+ cr7,ffc080c8 <rtems_termios_enqueue_raw_characters+0x12c><== NOT EXECUTED
}
}
}
}
tty->rawInBufDropped += dropped;
ffc081d8: 80 1f 00 78 lwz r0,120(r31)
rtems_semaphore_release (tty->rawInBuf.Semaphore);
ffc081dc: 80 7f 00 68 lwz r3,104(r31)
}
}
}
}
tty->rawInBufDropped += dropped;
ffc081e0: 7c 00 da 14 add r0,r0,r27
ffc081e4: 90 1f 00 78 stw r0,120(r31)
rtems_semaphore_release (tty->rawInBuf.Semaphore);
ffc081e8: 48 00 13 7d bl ffc09564 <rtems_semaphore_release>
return dropped;
}
ffc081ec: 80 01 00 3c lwz r0,60(r1)
ffc081f0: 7f 63 db 78 mr r3,r27
ffc081f4: 82 c1 00 10 lwz r22,16(r1)
ffc081f8: 7c 08 03 a6 mtlr r0
ffc081fc: 82 e1 00 14 lwz r23,20(r1)
ffc08200: 83 01 00 18 lwz r24,24(r1)
ffc08204: 83 21 00 1c lwz r25,28(r1)
ffc08208: 83 41 00 20 lwz r26,32(r1)
ffc0820c: 83 61 00 24 lwz r27,36(r1)
ffc08210: 83 81 00 28 lwz r28,40(r1)
ffc08214: 83 a1 00 2c lwz r29,44(r1)
ffc08218: 83 c1 00 30 lwz r30,48(r1)
ffc0821c: 83 e1 00 34 lwz r31,52(r1)
ffc08220: 38 21 00 38 addi r1,r1,56
ffc08224: 4e 80 00 20 blr
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
ffc08228: 89 3f 00 49 lbz r9,73(r31)
ffc0822c: 7f 89 00 00 cmpw cr7,r9,r0
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
ffc08230: 80 1f 00 b8 lwz r0,184(r31)
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
ffc08234: 41 9e 00 94 beq- cr7,ffc082c8 <rtems_termios_enqueue_raw_characters+0x32c><== NEVER TAKEN
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
ffc08238: 60 00 00 10 ori r0,r0,16
ffc0823c: 90 1f 00 b8 stw r0,184(r31)
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
{
ffc08240: 3b 20 00 01 li r25,1
flow_rcv = true;
}
}
if (flow_rcv) {
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
ffc08244: 80 1f 00 b8 lwz r0,184(r31)
ffc08248: 54 00 06 b6 rlwinm r0,r0,0,26,27
ffc0824c: 2f 80 00 20 cmpwi cr7,r0,32
ffc08250: 40 9e fe 70 bne+ cr7,ffc080c0 <rtems_termios_enqueue_raw_characters+0x124><== ALWAYS TAKEN
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc08254: 7f a0 00 a6 mfmsr r29 <== NOT EXECUTED
ffc08258: 7c 10 42 a6 mfsprg r0,0 <== NOT EXECUTED
ffc0825c: 7f a0 00 78 andc r0,r29,r0 <== NOT EXECUTED
ffc08260: 7c 00 01 24 mtmsr r0 <== NOT EXECUTED
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
ffc08264: 81 3f 00 94 lwz r9,148(r31) <== NOT EXECUTED
if (flow_rcv) {
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
ffc08268: 80 1f 00 b8 lwz r0,184(r31) <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
ffc0826c: 2f 89 00 00 cmpwi cr7,r9,0 <== NOT EXECUTED
if (flow_rcv) {
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
ffc08270: 54 00 06 f2 rlwinm r0,r0,0,27,25 <== NOT EXECUTED
ffc08274: 90 1f 00 b8 stw r0,184(r31) <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
ffc08278: 40 9e 00 0c bne- cr7,ffc08284 <rtems_termios_enqueue_raw_characters+0x2e8><== NOT EXECUTED
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0827c: 7f a0 01 24 mtmsr r29 <== NOT EXECUTED
ffc08280: 4b ff fe 40 b ffc080c0 <rtems_termios_enqueue_raw_characters+0x124><== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
ffc08284: 81 3f 00 84 lwz r9,132(r31) <== 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)(
ffc08288: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc0828c: 80 9f 00 7c lwz r4,124(r31) <== NOT EXECUTED
ffc08290: 80 1f 00 a4 lwz r0,164(r31) <== NOT EXECUTED
ffc08294: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc08298: 7c 84 4a 14 add r4,r4,r9 <== NOT EXECUTED
ffc0829c: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc082a0: 4e 80 04 21 bctrl <== NOT EXECUTED
ffc082a4: 7f a0 01 24 mtmsr r29 <== NOT EXECUTED
ffc082a8: 4b ff fe 18 b ffc080c0 <rtems_termios_enqueue_raw_characters+0x124><== NOT EXECUTED
/* reenable interrupts */
rtems_interrupt_enable(level);
if (newTail == tty->rawInBuf.Head) {
dropped++;
ffc082ac: 3b 7b 00 01 addi r27,r27,1 <== NOT EXECUTED
ffc082b0: 4b ff fe 10 b ffc080c0 <rtems_termios_enqueue_raw_characters+0x124><== NOT EXECUTED
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
ffc082b4: 80 1f 00 b8 lwz r0,184(r31) <== NOT EXECUTED
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
{
ffc082b8: 3b 20 00 01 li r25,1 <== NOT EXECUTED
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
ffc082bc: 54 00 07 34 rlwinm r0,r0,0,28,26 <== NOT EXECUTED
ffc082c0: 90 1f 00 b8 stw r0,184(r31) <== NOT EXECUTED
ffc082c4: 4b ff ff 80 b ffc08244 <rtems_termios_enqueue_raw_characters+0x2a8><== NOT EXECUTED
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
ffc082c8: 68 00 00 10 xori r0,r0,16 <== NOT EXECUTED
ffc082cc: 90 1f 00 b8 stw r0,184(r31) <== NOT EXECUTED
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
{
ffc082d0: 3b 20 00 01 li r25,1 <== NOT EXECUTED
ffc082d4: 4b ff ff 70 b ffc08244 <rtems_termios_enqueue_raw_characters+0x2a8><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
ffc082d8: 70 09 00 20 andi. r9,r0,32 <== NOT EXECUTED
ffc082dc: 40 82 00 10 bne- ffc082ec <rtems_termios_enqueue_raw_characters+0x350><== NOT EXECUTED
ffc082e0: 80 1f 00 94 lwz r0,148(r31) <== NOT EXECUTED
ffc082e4: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc082e8: 40 be fe 9c bne- cr7,ffc08184 <rtems_termios_enqueue_raw_characters+0x1e8><== 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;
ffc082ec: 81 3f 00 b8 lwz r9,184(r31) <== NOT EXECUTED
(*tty->device.write)(tty->minor,
ffc082f0: 7e c4 b3 78 mr r4,r22 <== NOT EXECUTED
ffc082f4: 80 1f 00 a4 lwz r0,164(r31) <== NOT EXECUTED
ffc082f8: 38 a0 00 01 li r5,1 <== 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;
ffc082fc: 61 29 00 02 ori r9,r9,2 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
ffc08300: 80 7f 00 10 lwz r3,16(r31) <== 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;
ffc08304: 91 3f 00 b8 stw r9,184(r31) <== NOT EXECUTED
(*tty->device.write)(tty->minor,
ffc08308: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc0830c: 4e 80 04 21 bctrl <== NOT EXECUTED
ffc08310: 4b ff fe 74 b ffc08184 <rtems_termios_enqueue_raw_characters+0x1e8><== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
tty->flow_ctrl |= FL_IRTSOFF;
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
ffc08314: 80 1f 00 ac lwz r0,172(r31) <== 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;
ffc08318: 81 3f 00 b8 lwz r9,184(r31) <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
ffc0831c: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
tty->flow_ctrl |= FL_IRTSOFF;
ffc08320: 61 29 00 04 ori r9,r9,4 <== NOT EXECUTED
ffc08324: 91 3f 00 b8 stw r9,184(r31) <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
ffc08328: 41 be fe 5c beq- cr7,ffc08184 <rtems_termios_enqueue_raw_characters+0x1e8><== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
ffc0832c: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc08330: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc08334: 4e 80 04 21 bctrl <== NOT EXECUTED
ffc08338: 4b ff fe 4c b ffc08184 <rtems_termios_enqueue_raw_characters+0x1e8><== NOT EXECUTED
ffc06cb8 <rtems_termios_ioctl>:
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
ffc06cb8: 94 21 ff e0 stwu r1,-32(r1)
ffc06cbc: 7c 08 02 a6 mflr r0
struct rtems_termios_tty *tty = args->iop->data1;
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);
ffc06cc0: 38 80 00 00 li r4,0
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
ffc06cc4: 90 01 00 24 stw r0,36(r1)
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
rtems_status_code sc;
args->ioctl_return = 0;
ffc06cc8: 38 00 00 00 li r0,0
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
ffc06ccc: 38 a0 00 00 li r5,0
rtems_status_code
rtems_termios_ioctl (void *arg)
{
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
ffc06cd0: 81 23 00 00 lwz r9,0(r3)
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
ffc06cd4: 93 c1 00 18 stw r30,24(r1)
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
ffc06cd8: 83 c9 00 38 lwz r30,56(r9)
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
ffc06cdc: 93 81 00 10 stw r28,16(r1)
ffc06ce0: 93 a1 00 14 stw r29,20(r1)
ffc06ce4: 93 e1 00 1c stw r31,28(r1)
ffc06ce8: 7c 7f 1b 78 mr r31,r3
ffc06cec: 93 41 00 08 stw r26,8(r1)
ffc06cf0: 93 61 00 0c stw r27,12(r1)
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
rtems_status_code sc;
args->ioctl_return = 0;
ffc06cf4: 90 03 00 0c stw r0,12(r3)
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
ffc06cf8: 80 7e 00 18 lwz r3,24(r30)
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;
ffc06cfc: 83 9f 00 08 lwz r28,8(r31)
rtems_status_code sc;
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
ffc06d00: 48 00 26 d9 bl ffc093d8 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
ffc06d04: 7c 7d 1b 79 mr. r29,r3
ffc06d08: 40 82 00 58 bne- ffc06d60 <rtems_termios_ioctl+0xa8> <== NEVER TAKEN
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
ffc06d0c: 80 1f 00 04 lwz r0,4(r31)
ffc06d10: 2f 80 00 04 cmpwi cr7,r0,4
ffc06d14: 41 9e 00 34 beq- cr7,ffc06d48 <rtems_termios_ioctl+0x90>
ffc06d18: 2b 80 00 04 cmplwi cr7,r0,4
ffc06d1c: 41 9d 00 74 bgt- cr7,ffc06d90 <rtems_termios_ioctl+0xd8>
ffc06d20: 2f 80 00 02 cmpwi cr7,r0,2
ffc06d24: 41 9e 00 c8 beq- cr7,ffc06dec <rtems_termios_ioctl+0x134>
ffc06d28: 2b 80 00 02 cmplwi cr7,r0,2
ffc06d2c: 40 9d 02 58 ble- cr7,ffc06f84 <rtems_termios_ioctl+0x2cc>
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
ffc06d30: 80 1e 00 b4 lwz r0,180(r30)
ffc06d34: 2f 80 00 00 cmpwi cr7,r0,0
ffc06d38: 41 be 00 20 beq+ cr7,ffc06d58 <rtems_termios_ioctl+0xa0><== ALWAYS TAKEN
ffc06d3c: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc06d40: 4b ff f8 29 bl ffc06568 <drainOutput.part.0> <== NOT EXECUTED
ffc06d44: 48 00 00 14 b ffc06d58 <rtems_termios_ioctl+0xa0> <== NOT EXECUTED
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
break;
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
ffc06d48: 81 5c 00 00 lwz r10,0(r28)
ffc06d4c: 81 7c 00 04 lwz r11,4(r28)
ffc06d50: 91 5e 00 dc stw r10,220(r30)
ffc06d54: 91 7e 00 e0 stw r11,224(r30)
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
}
break;
}
rtems_semaphore_release (tty->osem);
ffc06d58: 80 7e 00 18 lwz r3,24(r30)
ffc06d5c: 48 00 28 09 bl ffc09564 <rtems_semaphore_release>
args->ioctl_return = sc;
return sc;
}
ffc06d60: 80 01 00 24 lwz r0,36(r1)
ffc06d64: 7f a3 eb 78 mr r3,r29
}
break;
}
rtems_semaphore_release (tty->osem);
args->ioctl_return = sc;
ffc06d68: 93 bf 00 0c stw r29,12(r31)
return sc;
}
ffc06d6c: 7c 08 03 a6 mtlr r0
ffc06d70: 83 41 00 08 lwz r26,8(r1)
ffc06d74: 83 61 00 0c lwz r27,12(r1)
ffc06d78: 83 81 00 10 lwz r28,16(r1)
ffc06d7c: 83 a1 00 14 lwz r29,20(r1)
ffc06d80: 83 c1 00 18 lwz r30,24(r1)
ffc06d84: 83 e1 00 1c lwz r31,28(r1)
ffc06d88: 38 21 00 20 addi r1,r1,32
ffc06d8c: 4e 80 00 20 blr
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
ffc06d90: 3d 20 40 04 lis r9,16388
ffc06d94: 61 29 66 7f ori r9,r9,26239
ffc06d98: 7f 80 48 00 cmpw cr7,r0,r9
ffc06d9c: 41 9e 01 bc beq- cr7,ffc06f58 <rtems_termios_ioctl+0x2a0><== NEVER TAKEN
ffc06da0: 7f 80 48 40 cmplw cr7,r0,r9
ffc06da4: 41 9d 01 fc bgt- cr7,ffc06fa0 <rtems_termios_ioctl+0x2e8>
ffc06da8: 2f 80 00 05 cmpwi cr7,r0,5
ffc06dac: 41 9e 02 84 beq- cr7,ffc07030 <rtems_termios_ioctl+0x378>
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
ffc06db0: 80 1e 00 cc lwz r0,204(r30)
ffc06db4: 3d 20 00 00 lis r9,0
ffc06db8: 39 29 28 f0 addi r9,r9,10480
ffc06dbc: 54 00 28 34 rlwinm r0,r0,5,0,26
ffc06dc0: 7d 29 02 14 add r9,r9,r0
ffc06dc4: 80 09 00 18 lwz r0,24(r9)
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
}
else {
sc = RTEMS_INVALID_NUMBER;
ffc06dc8: 3b a0 00 0a li r29,10
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
ffc06dcc: 2f 80 00 00 cmpwi cr7,r0,0
ffc06dd0: 41 be ff 88 beq- cr7,ffc06d58 <rtems_termios_ioctl+0xa0><== NEVER TAKEN
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
ffc06dd4: 7f c3 f3 78 mr r3,r30
ffc06dd8: 7c 09 03 a6 mtctr r0
ffc06ddc: 7f e4 fb 78 mr r4,r31
ffc06de0: 4e 80 04 21 bctrl
ffc06de4: 7c 7d 1b 78 mr r29,r3
ffc06de8: 4b ff ff 70 b ffc06d58 <rtems_termios_ioctl+0xa0>
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
break;
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
ffc06dec: 3b 9e 00 30 addi r28,r30,48
ffc06df0: 80 9f 00 08 lwz r4,8(r31)
ffc06df4: 7f 83 e3 78 mr r3,r28
ffc06df8: 38 a0 00 24 li r5,36
ffc06dfc: 48 00 dc cd bl ffc14ac8 <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) &&
ffc06e00: 80 1e 00 b8 lwz r0,184(r30)
ffc06e04: 70 09 02 00 andi. r9,r0,512
ffc06e08: 41 82 00 58 beq- ffc06e60 <rtems_termios_ioctl+0x1a8>
!(tty->termios.c_iflag & IXON)) {
ffc06e0c: 80 1e 00 30 lwz r0,48(r30)
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
ffc06e10: 70 09 04 00 andi. r9,r0,1024
ffc06e14: 40 82 00 4c bne- ffc06e60 <rtems_termios_ioctl+0x1a8>
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
ffc06e18: 81 3e 00 b8 lwz r9,184(r30)
ffc06e1c: 38 00 fd ef li r0,-529
ffc06e20: 7d 20 00 38 and r0,r9,r0
ffc06e24: 90 1e 00 b8 stw r0,184(r30)
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
ffc06e28: 80 1e 00 b8 lwz r0,184(r30)
ffc06e2c: 70 09 00 20 andi. r9,r0,32
ffc06e30: 41 82 00 30 beq- ffc06e60 <rtems_termios_ioctl+0x1a8> <== ALWAYS TAKEN
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc06e34: 7f 60 00 a6 mfmsr r27 <== NOT EXECUTED
ffc06e38: 7c 10 42 a6 mfsprg r0,0 <== NOT EXECUTED
ffc06e3c: 7f 60 00 78 andc r0,r27,r0 <== NOT EXECUTED
ffc06e40: 7c 00 01 24 mtmsr r0 <== NOT EXECUTED
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
ffc06e44: 81 3e 00 94 lwz r9,148(r30) <== NOT EXECUTED
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
ffc06e48: 80 1e 00 b8 lwz r0,184(r30) <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
ffc06e4c: 2f 89 00 00 cmpwi cr7,r9,0 <== NOT EXECUTED
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
ffc06e50: 54 00 06 f2 rlwinm r0,r0,0,27,25 <== NOT EXECUTED
ffc06e54: 90 1e 00 b8 stw r0,184(r30) <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
ffc06e58: 40 9e 02 50 bne- cr7,ffc070a8 <rtems_termios_ioctl+0x3f0><== NOT EXECUTED
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc06e5c: 7f 60 01 24 mtmsr r27 <== NOT EXECUTED
/* reenable interrupts */
rtems_interrupt_enable(level);
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
ffc06e60: 80 1e 00 b8 lwz r0,184(r30)
ffc06e64: 70 09 04 00 andi. r9,r0,1024
ffc06e68: 41 82 00 28 beq- ffc06e90 <rtems_termios_ioctl+0x1d8>
ffc06e6c: 80 1e 00 30 lwz r0,48(r30)
ffc06e70: 70 09 10 00 andi. r9,r0,4096
ffc06e74: 40 82 00 1c bne- ffc06e90 <rtems_termios_ioctl+0x1d8> <== NEVER TAKEN
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
ffc06e78: 80 1e 00 b8 lwz r0,184(r30)
ffc06e7c: 54 00 05 a8 rlwinm r0,r0,0,22,20
ffc06e80: 90 1e 00 b8 stw r0,184(r30)
/* FIXME: what happens, if we had sent XOFF but not yet XON? */
tty->flow_ctrl &= ~(FL_ISNTXOF);
ffc06e84: 80 1e 00 b8 lwz r0,184(r30)
ffc06e88: 54 00 07 fa rlwinm r0,r0,0,31,29
ffc06e8c: 90 1e 00 b8 stw r0,184(r30)
}
/* check for incoming RTS/CTS flow control switched off */
if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) {
ffc06e90: 80 1e 00 b8 lwz r0,184(r30)
ffc06e94: 70 09 01 00 andi. r9,r0,256
ffc06e98: 80 1e 00 38 lwz r0,56(r30)
ffc06e9c: 2f 80 00 00 cmpwi cr7,r0,0
ffc06ea0: 41 82 00 4c beq- ffc06eec <rtems_termios_ioctl+0x234> <== ALWAYS TAKEN
ffc06ea4: 41 9c 01 f4 blt- cr7,ffc07098 <rtems_termios_ioctl+0x3e0><== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
ffc06ea8: 80 1e 00 b8 lwz r0,184(r30) <== NOT EXECUTED
ffc06eac: 54 00 06 2c rlwinm r0,r0,0,24,22 <== NOT EXECUTED
ffc06eb0: 90 1e 00 b8 stw r0,184(r30) <== NOT EXECUTED
/* restart remote Tx, if it was stopped */
if ((tty->flow_ctrl & FL_IRTSOFF) && (tty->device.startRemoteTx != NULL)) {
ffc06eb4: 80 1e 00 b8 lwz r0,184(r30) <== NOT EXECUTED
ffc06eb8: 70 09 00 04 andi. r9,r0,4 <== NOT EXECUTED
ffc06ebc: 41 82 00 24 beq- ffc06ee0 <rtems_termios_ioctl+0x228> <== NOT EXECUTED
ffc06ec0: 80 1e 00 b0 lwz r0,176(r30) <== NOT EXECUTED
ffc06ec4: 2f 00 00 00 cmpwi cr6,r0,0 <== NOT EXECUTED
ffc06ec8: 41 9a 00 18 beq- cr6,ffc06ee0 <rtems_termios_ioctl+0x228><== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
ffc06ecc: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc06ed0: 80 7e 00 10 lwz r3,16(r30) <== NOT EXECUTED
ffc06ed4: 4e 80 04 21 bctrl <== NOT EXECUTED
ffc06ed8: 80 1e 00 38 lwz r0,56(r30) <== NOT EXECUTED
ffc06edc: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
ffc06ee0: 80 1e 00 b8 lwz r0,184(r30) <== NOT EXECUTED
ffc06ee4: 54 00 07 b8 rlwinm r0,r0,0,30,28 <== NOT EXECUTED
ffc06ee8: 90 1e 00 b8 stw r0,184(r30) <== 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) {
ffc06eec: 41 9c 01 ac blt- cr7,ffc07098 <rtems_termios_ioctl+0x3e0><== NEVER TAKEN
tty->flow_ctrl |= FL_MDRTS;
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
ffc06ef0: 80 1e 00 30 lwz r0,48(r30)
ffc06ef4: 70 09 10 00 andi. r9,r0,4096
ffc06ef8: 41 82 00 10 beq- ffc06f08 <rtems_termios_ioctl+0x250>
tty->flow_ctrl |= FL_MDXOF;
ffc06efc: 81 3e 00 b8 lwz r9,184(r30)
ffc06f00: 61 29 04 00 ori r9,r9,1024
ffc06f04: 91 3e 00 b8 stw r9,184(r30)
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
ffc06f08: 70 09 04 00 andi. r9,r0,1024
ffc06f0c: 41 82 00 10 beq- ffc06f1c <rtems_termios_ioctl+0x264>
tty->flow_ctrl |= FL_MDXON;
ffc06f10: 80 1e 00 b8 lwz r0,184(r30)
ffc06f14: 60 00 02 00 ori r0,r0,512
ffc06f18: 90 1e 00 b8 stw r0,184(r30)
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) {
ffc06f1c: 83 7e 00 3c lwz r27,60(r30)
ffc06f20: 73 7b 00 02 andi. r27,r27,2
ffc06f24: 41 82 01 20 beq- ffc07044 <rtems_termios_ioctl+0x38c>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
ffc06f28: 38 00 00 00 li r0,0
ffc06f2c: 90 1e 00 6c stw r0,108(r30)
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
ffc06f30: 90 1e 00 70 stw r0,112(r30)
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
ffc06f34: 90 1e 00 74 stw r0,116(r30)
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
}
}
}
if (tty->device.setAttributes)
ffc06f38: 80 1e 00 a8 lwz r0,168(r30)
ffc06f3c: 2f 80 00 00 cmpwi cr7,r0,0
ffc06f40: 41 be fe 18 beq- cr7,ffc06d58 <rtems_termios_ioctl+0xa0><== NEVER TAKEN
(*tty->device.setAttributes)(tty->minor, &tty->termios);
ffc06f44: 80 7e 00 10 lwz r3,16(r30)
ffc06f48: 7f 84 e3 78 mr r4,r28
ffc06f4c: 7c 09 03 a6 mtctr r0
ffc06f50: 4e 80 04 21 bctrl
ffc06f54: 4b ff fe 04 b ffc06d58 <rtems_termios_ioctl+0xa0>
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
ffc06f58: 81 3e 00 60 lwz r9,96(r30) <== NOT EXECUTED
ffc06f5c: 80 1e 00 5c lwz r0,92(r30) <== NOT EXECUTED
if ( rawnc < 0 )
ffc06f60: 7c 00 48 51 subf. r0,r0,r9 <== NOT EXECUTED
ffc06f64: 41 80 01 28 blt- ffc0708c <rtems_termios_ioctl+0x3d4> <== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
ffc06f68: 81 5e 00 20 lwz r10,32(r30) <== NOT EXECUTED
ffc06f6c: 81 3e 00 24 lwz r9,36(r30) <== NOT EXECUTED
ffc06f70: 81 7f 00 08 lwz r11,8(r31) <== NOT EXECUTED
ffc06f74: 7d 29 50 50 subf r9,r9,r10 <== NOT EXECUTED
ffc06f78: 7c 09 02 14 add r0,r9,r0 <== NOT EXECUTED
ffc06f7c: 90 0b 00 00 stw r0,0(r11) <== NOT EXECUTED
}
break;
ffc06f80: 4b ff fd d8 b ffc06d58 <rtems_termios_ioctl+0xa0> <== NOT EXECUTED
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
ffc06f84: 2f 80 00 01 cmpwi cr7,r0,1
ffc06f88: 40 9e fe 28 bne+ cr7,ffc06db0 <rtems_termios_ioctl+0xf8><== NEVER TAKEN
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
ffc06f8c: 80 7f 00 08 lwz r3,8(r31)
ffc06f90: 38 9e 00 30 addi r4,r30,48
ffc06f94: 38 a0 00 24 li r5,36
ffc06f98: 48 00 db 31 bl ffc14ac8 <memcpy>
break;
ffc06f9c: 4b ff fd bc b ffc06d58 <rtems_termios_ioctl+0xa0>
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
ffc06fa0: 6c 09 40 04 xoris r9,r0,16388
ffc06fa4: 2f 89 74 1a cmpwi cr7,r9,29722
ffc06fa8: 41 9e 00 78 beq- cr7,ffc07020 <rtems_termios_ioctl+0x368>
ffc06fac: 6c 09 80 04 xoris r9,r0,32772
ffc06fb0: 2f 89 74 1b cmpwi cr7,r9,29723
ffc06fb4: 40 9e fd fc bne+ cr7,ffc06db0 <rtems_termios_ioctl+0xf8><== NEVER TAKEN
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
ffc06fb8: 81 3e 00 cc lwz r9,204(r30)
ffc06fbc: 3f 80 00 00 lis r28,0
ffc06fc0: 3b 9c 28 f0 addi r28,r28,10480
ffc06fc4: 55 29 28 34 rlwinm r9,r9,5,0,26
ffc06fc8: 7d 3c 4a 14 add r9,r28,r9
ffc06fcc: 80 09 00 04 lwz r0,4(r9)
ffc06fd0: 2f 80 00 00 cmpwi cr7,r0,0
ffc06fd4: 41 9e 00 14 beq- cr7,ffc06fe8 <rtems_termios_ioctl+0x330>
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
ffc06fd8: 7f c3 f3 78 mr r3,r30
ffc06fdc: 7c 09 03 a6 mtctr r0
ffc06fe0: 4e 80 04 21 bctrl
ffc06fe4: 7c 7d 1b 78 mr r29,r3
}
tty->t_line=*(int*)(args->buffer);
ffc06fe8: 81 3f 00 08 lwz r9,8(r31)
tty->t_sc = NULL; /* ensure that no more valid data */
ffc06fec: 38 00 00 00 li r0,0
* 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);
ffc06ff0: 81 29 00 00 lwz r9,0(r9)
tty->t_sc = NULL; /* ensure that no more valid data */
ffc06ff4: 90 1e 00 d0 stw r0,208(r30)
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
ffc06ff8: 55 20 28 34 rlwinm r0,r9,5,0,26
ffc06ffc: 7c 1c 00 2e lwzx r0,r28,r0
* 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);
ffc07000: 91 3e 00 cc stw r9,204(r30)
tty->t_sc = NULL; /* ensure that no more valid data */
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
ffc07004: 2f 80 00 00 cmpwi cr7,r0,0
ffc07008: 41 be fd 50 beq- cr7,ffc06d58 <rtems_termios_ioctl+0xa0>
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
ffc0700c: 7f c3 f3 78 mr r3,r30
ffc07010: 7c 09 03 a6 mtctr r0
ffc07014: 4e 80 04 21 bctrl
ffc07018: 7c 7d 1b 78 mr r29,r3
ffc0701c: 4b ff fd 3c b ffc06d58 <rtems_termios_ioctl+0xa0>
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
ffc07020: 80 1e 00 cc lwz r0,204(r30)
ffc07024: 81 3f 00 08 lwz r9,8(r31)
ffc07028: 90 09 00 00 stw r0,0(r9)
break;
ffc0702c: 4b ff fd 2c b ffc06d58 <rtems_termios_ioctl+0xa0>
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
ffc07030: 81 5c 00 00 lwz r10,0(r28)
ffc07034: 81 7c 00 04 lwz r11,4(r28)
ffc07038: 91 5e 00 d4 stw r10,212(r30)
ffc0703c: 91 7e 00 d8 stw r11,216(r30)
break;
ffc07040: 4b ff fd 18 b ffc06d58 <rtems_termios_ioctl+0xa0>
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] *
ffc07044: 8b 5e 00 46 lbz r26,70(r30)
rtems_clock_get_ticks_per_second() / 10;
ffc07048: 48 00 1b 91 bl ffc08bd8 <rtems_clock_get_ticks_per_second>
if (tty->termios.c_cc[VTIME]) {
ffc0704c: 89 3e 00 46 lbz r9,70(r30)
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
rtems_clock_get_ticks_per_second() / 10;
ffc07050: 3c 00 cc cc lis r0,-13108
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] *
ffc07054: 7c 63 d1 d6 mullw r3,r3,r26
rtems_clock_get_ticks_per_second() / 10;
ffc07058: 60 00 cc cd ori r0,r0,52429
if (tty->termios.c_cc[VTIME]) {
ffc0705c: 2f 89 00 00 cmpwi cr7,r9,0
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
rtems_clock_get_ticks_per_second() / 10;
ffc07060: 7c 03 00 16 mulhwu r0,r3,r0
ffc07064: 54 00 e8 fe rlwinm r0,r0,29,3,31
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] *
ffc07068: 90 1e 00 54 stw r0,84(r30)
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
ffc0706c: 41 9e 00 64 beq- cr7,ffc070d0 <rtems_termios_ioctl+0x418>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
ffc07070: 89 3e 00 47 lbz r9,71(r30)
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
ffc07074: 93 7e 00 6c stw r27,108(r30)
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
ffc07078: 2f 89 00 00 cmpwi cr7,r9,0
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
ffc0707c: 90 1e 00 70 stw r0,112(r30)
if (tty->termios.c_cc[VMIN])
ffc07080: 41 9e 00 6c beq- cr7,ffc070ec <rtems_termios_ioctl+0x434>
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
ffc07084: 93 7e 00 74 stw r27,116(r30)
ffc07088: 4b ff fe b0 b ffc06f38 <rtems_termios_ioctl+0x280>
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
if ( rawnc < 0 )
rawnc += tty->rawInBuf.Size;
ffc0708c: 81 3e 00 64 lwz r9,100(r30) <== NOT EXECUTED
ffc07090: 7c 00 4a 14 add r0,r0,r9 <== NOT EXECUTED
ffc07094: 4b ff fe d4 b ffc06f68 <rtems_termios_ioctl+0x2b0> <== 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) {
tty->flow_ctrl |= FL_MDRTS;
ffc07098: 80 1e 00 b8 lwz r0,184(r30) <== NOT EXECUTED
ffc0709c: 60 00 01 00 ori r0,r0,256 <== NOT EXECUTED
ffc070a0: 90 1e 00 b8 stw r0,184(r30) <== NOT EXECUTED
ffc070a4: 4b ff fe 4c b ffc06ef0 <rtems_termios_ioctl+0x238> <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
ffc070a8: 81 3e 00 84 lwz r9,132(r30) <== 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)(
ffc070ac: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc070b0: 80 9e 00 7c lwz r4,124(r30) <== NOT EXECUTED
ffc070b4: 80 1e 00 a4 lwz r0,164(r30) <== NOT EXECUTED
ffc070b8: 80 7e 00 10 lwz r3,16(r30) <== NOT EXECUTED
ffc070bc: 7c 84 4a 14 add r4,r4,r9 <== NOT EXECUTED
ffc070c0: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc070c4: 4e 80 04 21 bctrl <== NOT EXECUTED
ffc070c8: 7f 60 01 24 mtmsr r27 <== NOT EXECUTED
ffc070cc: 4b ff fd 94 b ffc06e60 <rtems_termios_ioctl+0x1a8> <== NOT EXECUTED
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
} else {
if (tty->termios.c_cc[VMIN]) {
ffc070d0: 88 1e 00 47 lbz r0,71(r30)
ffc070d4: 2f 80 00 00 cmpwi cr7,r0,0
ffc070d8: 41 9e 00 1c beq- cr7,ffc070f4 <rtems_termios_ioctl+0x43c><== ALWAYS TAKEN
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
ffc070dc: 91 3e 00 6c stw r9,108(r30) <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
ffc070e0: 91 3e 00 70 stw r9,112(r30) <== NOT EXECUTED
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
ffc070e4: 91 3e 00 74 stw r9,116(r30) <== NOT EXECUTED
ffc070e8: 4b ff fe 50 b ffc06f38 <rtems_termios_ioctl+0x280> <== NOT EXECUTED
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
ffc070ec: 90 1e 00 74 stw r0,116(r30)
ffc070f0: 4b ff fe 48 b ffc06f38 <rtems_termios_ioctl+0x280>
if (tty->termios.c_cc[VMIN]) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
ffc070f4: 38 00 00 01 li r0,1
ffc070f8: 90 1e 00 6c stw r0,108(r30)
ffc070fc: 4b ff fe 3c b ffc06f38 <rtems_termios_ioctl+0x280>
ffc06604 <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
ffc06604: 94 21 ff c0 stwu r1,-64(r1)
ffc06608: 7d 80 00 26 mfcr r12
ffc0660c: 7c 08 02 a6 mflr r0
ffc06610: 93 81 00 30 stw r28,48(r1)
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
ffc06614: 3f 80 00 00 lis r28,0
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
ffc06618: 93 c1 00 38 stw r30,56(r1)
ffc0661c: 7c 7e 1b 78 mr r30,r3
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
ffc06620: 80 7c 27 fc lwz r3,10236(r28)
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
ffc06624: 93 41 00 28 stw r26,40(r1)
ffc06628: 7c ba 2b 78 mr r26,r5
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
ffc0662c: 38 a0 00 00 li r5,0
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
ffc06630: 93 a1 00 34 stw r29,52(r1)
ffc06634: 7c 9d 23 78 mr r29,r4
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
ffc06638: 38 80 00 00 li r4,0
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
ffc0663c: 93 01 00 20 stw r24,32(r1)
ffc06640: 7c d8 33 78 mr r24,r6
ffc06644: 93 61 00 2c stw r27,44(r1)
ffc06648: 90 01 00 44 stw r0,68(r1)
ffc0664c: 92 81 00 10 stw r20,16(r1)
ffc06650: 92 a1 00 14 stw r21,20(r1)
ffc06654: 92 c1 00 18 stw r22,24(r1)
ffc06658: 92 e1 00 1c stw r23,28(r1)
ffc0665c: 93 21 00 24 stw r25,36(r1)
ffc06660: 93 e1 00 3c stw r31,60(r1)
ffc06664: 91 81 00 0c stw r12,12(r1)
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
ffc06668: 48 00 2d 71 bl ffc093d8 <rtems_semaphore_obtain>
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc0666c: 7c 7b 1b 79 mr. r27,r3
ffc06670: 40 82 00 90 bne- ffc06700 <rtems_termios_open+0xfc> <== NEVER TAKEN
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
ffc06674: 3e c0 00 00 lis r22,0
ffc06678: 82 f6 28 04 lwz r23,10244(r22)
ffc0667c: 2e 17 00 00 cmpwi cr4,r23,0
ffc06680: 41 92 01 08 beq- cr4,ffc06788 <rtems_termios_open+0x184>
ffc06684: 7e ff bb 78 mr r31,r23
ffc06688: 48 00 00 10 b ffc06698 <rtems_termios_open+0x94>
ffc0668c: 83 ff 00 00 lwz r31,0(r31)
ffc06690: 2f 9f 00 00 cmpwi cr7,r31,0
ffc06694: 41 9e 00 f4 beq- cr7,ffc06788 <rtems_termios_open+0x184><== ALWAYS TAKEN
if ((tty->major == major) && (tty->minor == minor))
ffc06698: 80 1f 00 0c lwz r0,12(r31)
ffc0669c: 7f 80 f0 00 cmpw cr7,r0,r30
ffc066a0: 40 9e ff ec bne+ cr7,ffc0668c <rtems_termios_open+0x88>
ffc066a4: 80 1f 00 10 lwz r0,16(r31)
ffc066a8: 7f 80 e8 00 cmpw cr7,r0,r29
ffc066ac: 40 9e ff e0 bne+ cr7,ffc0668c <rtems_termios_open+0x88> <== NEVER TAKEN
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
if (!tty->refcount++) {
ffc066b0: 81 3f 00 08 lwz r9,8(r31)
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
ffc066b4: 81 7a 00 00 lwz r11,0(r26)
if (!tty->refcount++) {
ffc066b8: 2f 89 00 00 cmpwi cr7,r9,0
ffc066bc: 39 29 00 01 addi r9,r9,1
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
ffc066c0: 93 eb 00 38 stw r31,56(r11)
if (!tty->refcount++) {
ffc066c4: 91 3f 00 08 stw r9,8(r31)
ffc066c8: 40 9e 00 30 bne- cr7,ffc066f8 <rtems_termios_open+0xf4>
if (tty->device.firstOpen)
ffc066cc: 80 1f 00 98 lwz r0,152(r31)
ffc066d0: 2f 80 00 00 cmpwi cr7,r0,0
ffc066d4: 41 9e 00 18 beq- cr7,ffc066ec <rtems_termios_open+0xe8> <== ALWAYS TAKEN
(*tty->device.firstOpen)(major, minor, arg);
ffc066d8: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc066dc: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc066e0: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc066e4: 7f 45 d3 78 mr r5,r26 <== NOT EXECUTED
ffc066e8: 4e 80 04 21 bctrl <== NOT EXECUTED
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
ffc066ec: 80 1f 00 b4 lwz r0,180(r31)
ffc066f0: 2f 80 00 02 cmpwi cr7,r0,2
ffc066f4: 41 9e 00 58 beq- cr7,ffc0674c <rtems_termios_open+0x148>
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
ffc066f8: 80 7c 27 fc lwz r3,10236(r28)
ffc066fc: 48 00 2e 69 bl ffc09564 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
}
ffc06700: 80 01 00 44 lwz r0,68(r1)
ffc06704: 7f 63 db 78 mr r3,r27
ffc06708: 81 81 00 0c lwz r12,12(r1)
ffc0670c: 7c 08 03 a6 mtlr r0
ffc06710: 82 81 00 10 lwz r20,16(r1)
ffc06714: 82 a1 00 14 lwz r21,20(r1)
ffc06718: 7d 80 81 20 mtcrf 8,r12
ffc0671c: 82 c1 00 18 lwz r22,24(r1)
ffc06720: 82 e1 00 1c lwz r23,28(r1)
ffc06724: 83 01 00 20 lwz r24,32(r1)
ffc06728: 83 21 00 24 lwz r25,36(r1)
ffc0672c: 83 41 00 28 lwz r26,40(r1)
ffc06730: 83 61 00 2c lwz r27,44(r1)
ffc06734: 83 81 00 30 lwz r28,48(r1)
ffc06738: 83 a1 00 34 lwz r29,52(r1)
ffc0673c: 83 c1 00 38 lwz r30,56(r1)
ffc06740: 83 e1 00 3c lwz r31,60(r1)
ffc06744: 38 21 00 40 addi r1,r1,64
ffc06748: 4e 80 00 20 blr
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_start(
ffc0674c: 80 7f 00 c4 lwz r3,196(r31)
ffc06750: 3c 80 ff c1 lis r4,-63
ffc06754: 38 84 83 3c addi r4,r4,-31940
ffc06758: 7f e5 fb 78 mr r5,r31
ffc0675c: 48 00 32 39 bl ffc09994 <rtems_task_start>
tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
ffc06760: 2f 83 00 00 cmpwi cr7,r3,0
ffc06764: 40 9e 02 d4 bne- cr7,ffc06a38 <rtems_termios_open+0x434><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
ffc06768: 80 7f 00 c8 lwz r3,200(r31)
ffc0676c: 3c 80 ff c1 lis r4,-63
ffc06770: 38 84 86 30 addi r4,r4,-31184
ffc06774: 7f e5 fb 78 mr r5,r31
ffc06778: 48 00 32 1d bl ffc09994 <rtems_task_start>
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
ffc0677c: 2f 83 00 00 cmpwi cr7,r3,0
ffc06780: 41 9e ff 78 beq+ cr7,ffc066f8 <rtems_termios_open+0xf4> <== ALWAYS TAKEN
ffc06784: 48 00 02 b4 b ffc06a38 <rtems_termios_open+0x434> <== NOT EXECUTED
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
ffc06788: 38 60 00 01 li r3,1
ffc0678c: 38 80 00 e8 li r4,232
ffc06790: 4b ff e4 09 bl ffc04b98 <calloc>
if (tty == NULL) {
ffc06794: 7c 7f 1b 79 mr. r31,r3
ffc06798: 41 82 02 68 beq- ffc06a00 <rtems_termios_open+0x3fc>
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
ffc0679c: 3f 20 00 00 lis r25,0
ffc067a0: 80 19 21 b0 lwz r0,8624(r25)
ffc067a4: 3b 39 21 b0 addi r25,r25,8624
ffc067a8: 90 1f 00 64 stw r0,100(r31)
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
ffc067ac: 80 7f 00 64 lwz r3,100(r31)
ffc067b0: 4b ff ee 09 bl ffc055b8 <malloc>
if (tty->rawInBuf.theBuf == NULL) {
ffc067b4: 2f 83 00 00 cmpwi cr7,r3,0
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
ffc067b8: 90 7f 00 58 stw r3,88(r31)
ffc067bc: 7c 75 1b 78 mr r21,r3
if (tty->rawInBuf.theBuf == NULL) {
ffc067c0: 41 9e 02 38 beq- cr7,ffc069f8 <rtems_termios_open+0x3f4>
return RTEMS_NO_MEMORY;
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
ffc067c4: 80 19 00 04 lwz r0,4(r25)
ffc067c8: 90 1f 00 88 stw r0,136(r31)
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
ffc067cc: 80 7f 00 88 lwz r3,136(r31)
ffc067d0: 4b ff ed e9 bl ffc055b8 <malloc>
if (tty->rawOutBuf.theBuf == NULL) {
ffc067d4: 2f 83 00 00 cmpwi cr7,r3,0
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
ffc067d8: 90 7f 00 7c stw r3,124(r31)
ffc067dc: 7c 74 1b 78 mr r20,r3
if (tty->rawOutBuf.theBuf == NULL) {
ffc067e0: 41 9e 02 10 beq- cr7,ffc069f0 <rtems_termios_open+0x3ec>
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
ffc067e4: 80 79 00 08 lwz r3,8(r25)
ffc067e8: 4b ff ed d1 bl ffc055b8 <malloc>
if (tty->cbuf == NULL) {
ffc067ec: 2f 83 00 00 cmpwi cr7,r3,0
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
ffc067f0: 90 7f 00 1c stw r3,28(r31)
if (tty->cbuf == NULL) {
ffc067f4: 41 9e 01 f4 beq- cr7,ffc069e8 <rtems_termios_open+0x3e4><== NEVER TAKEN
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
ffc067f8: 38 00 00 00 li r0,0
tty->tty_rcvwakeup = 0;
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
ffc067fc: 92 ff 00 00 stw r23,0(r31)
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
ffc06800: 90 1f 00 d4 stw r0,212(r31)
tty->tty_snd.sw_arg = NULL;
ffc06804: 90 1f 00 d8 stw r0,216(r31)
tty->tty_rcv.sw_pfn = NULL;
ffc06808: 90 1f 00 dc stw r0,220(r31)
tty->tty_rcv.sw_arg = NULL;
ffc0680c: 90 1f 00 e0 stw r0,224(r31)
tty->tty_rcvwakeup = 0;
ffc06810: 90 1f 00 e4 stw r0,228(r31)
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
ffc06814: 90 1f 00 04 stw r0,4(r31)
if (rtems_termios_ttyHead != NULL)
ffc06818: 41 92 00 08 beq- cr4,ffc06820 <rtems_termios_open+0x21c>
rtems_termios_ttyHead->back = tty;
ffc0681c: 93 f7 00 04 stw r31,4(r23)
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
ffc06820: 3d 20 00 00 lis r9,0
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
ffc06824: 93 f6 28 04 stw r31,10244(r22)
if (rtems_termios_ttyTail == NULL)
ffc06828: 80 09 28 00 lwz r0,10240(r9)
ffc0682c: 2f 80 00 00 cmpwi cr7,r0,0
ffc06830: 41 9e 02 68 beq- cr7,ffc06a98 <rtems_termios_open+0x494>
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'i', c),
ffc06834: 88 79 00 0c lbz r3,12(r25)
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
ffc06838: 38 80 00 01 li r4,1
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
tty->minor = minor;
ffc0683c: 93 bf 00 10 stw r29,16(r31)
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
ffc06840: 38 a0 00 54 li r5,84
ffc06844: 64 63 54 52 oris r3,r3,21586
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
tty->minor = minor;
tty->major = major;
ffc06848: 93 df 00 0c stw r30,12(r31)
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
ffc0684c: 60 63 69 00 ori r3,r3,26880
ffc06850: 38 c0 00 00 li r6,0
ffc06854: 38 ff 00 14 addi r7,r31,20
ffc06858: 48 00 28 a9 bl ffc09100 <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'i', c),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
ffc0685c: 2f 83 00 00 cmpwi cr7,r3,0
ffc06860: 40 9e 01 d8 bne- cr7,ffc06a38 <rtems_termios_open+0x434>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'o', c),
ffc06864: 88 79 00 0c lbz r3,12(r25)
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 (
ffc06868: 38 80 00 01 li r4,1
ffc0686c: 38 a0 00 54 li r5,84
ffc06870: 64 63 54 52 oris r3,r3,21586
ffc06874: 60 63 6f 00 ori r3,r3,28416
ffc06878: 38 c0 00 00 li r6,0
ffc0687c: 38 ff 00 18 addi r7,r31,24
ffc06880: 48 00 28 81 bl ffc09100 <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'o', c),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->osem);
if (sc != RTEMS_SUCCESSFUL)
ffc06884: 2f 83 00 00 cmpwi cr7,r3,0
ffc06888: 40 9e 01 b0 bne- cr7,ffc06a38 <rtems_termios_open+0x434>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'x', c),
ffc0688c: 88 79 00 0c lbz r3,12(r25)
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 (
ffc06890: 38 80 00 00 li r4,0
ffc06894: 38 a0 00 20 li r5,32
ffc06898: 64 63 54 52 oris r3,r3,21586
ffc0689c: 60 63 78 00 ori r3,r3,30720
ffc068a0: 38 c0 00 00 li r6,0
ffc068a4: 38 ff 00 8c addi r7,r31,140
ffc068a8: 48 00 28 59 bl ffc09100 <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'x', c),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO,
RTEMS_NO_PRIORITY,
&tty->rawOutBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
ffc068ac: 7c 60 1b 79 mr. r0,r3
ffc068b0: 40 82 01 88 bne- ffc06a38 <rtems_termios_open+0x434>
tty->rawOutBufState = rob_idle;
/*
* Set callbacks
*/
tty->device = *callbacks;
ffc068b4: 81 18 00 00 lwz r8,0(r24)
ffc068b8: 81 58 00 04 lwz r10,4(r24)
ffc068bc: 81 78 00 08 lwz r11,8(r24)
ffc068c0: 81 38 00 0c lwz r9,12(r24)
ffc068c4: 91 1f 00 98 stw r8,152(r31)
ffc068c8: 91 5f 00 9c stw r10,156(r31)
ffc068cc: 91 7f 00 a0 stw r11,160(r31)
ffc068d0: 91 3f 00 a4 stw r9,164(r31)
ffc068d4: 81 38 00 1c lwz r9,28(r24)
ffc068d8: 81 18 00 10 lwz r8,16(r24)
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
ffc068dc: 2f 89 00 02 cmpwi cr7,r9,2
tty->rawOutBufState = rob_idle;
/*
* Set callbacks
*/
tty->device = *callbacks;
ffc068e0: 81 58 00 14 lwz r10,20(r24)
ffc068e4: 81 78 00 18 lwz r11,24(r24)
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;
ffc068e8: 90 1f 00 94 stw r0,148(r31)
/*
* Set callbacks
*/
tty->device = *callbacks;
ffc068ec: 91 1f 00 a8 stw r8,168(r31)
ffc068f0: 91 5f 00 ac stw r10,172(r31)
ffc068f4: 91 7f 00 b0 stw r11,176(r31)
ffc068f8: 91 3f 00 b4 stw r9,180(r31)
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
ffc068fc: 41 9e 01 40 beq- cr7,ffc06a3c <rtems_termios_open+0x438>
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
ffc06900: 80 1f 00 a0 lwz r0,160(r31)
ffc06904: 2f 80 00 00 cmpwi cr7,r0,0
ffc06908: 41 9e 01 08 beq- cr7,ffc06a10 <rtems_termios_open+0x40c>
ffc0690c: 80 1f 00 b4 lwz r0,180(r31)
ffc06910: 2f 80 00 02 cmpwi cr7,r0,2
ffc06914: 41 9e 00 fc beq- cr7,ffc06a10 <rtems_termios_open+0x40c>
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
ffc06918: 39 00 25 02 li r8,9474
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
ffc0691c: 89 39 00 0c lbz r9,12(r25)
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
ffc06920: 91 1f 00 30 stw r8,48(r31)
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
ffc06924: 39 00 18 05 li r8,6149
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
ffc06928: 38 00 00 00 li r0,0
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
ffc0692c: 91 1f 00 34 stw r8,52(r31)
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
ffc06930: 39 00 08 bd li r8,2237
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
ffc06934: 2f 89 00 7a cmpwi cr7,r9,122
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
ffc06938: 90 1f 00 b8 stw r0,184(r31)
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
ffc0693c: 39 29 00 01 addi r9,r9,1
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
ffc06940: 91 1f 00 38 stw r8,56(r31)
tty->termios.c_lflag =
ffc06944: 39 00 00 00 li r8,0
ffc06948: 61 08 82 3b ori r8,r8,33339
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';
ffc0694c: 98 1f 00 4c stb r0,76(r31)
tty->termios.c_cc[VEOL2] = '\000';
ffc06950: 98 1f 00 51 stb r0,81(r31)
tty->termios.c_cc[VSTART] = '\021';
ffc06954: 38 00 00 11 li r0,17
ffc06958: 98 1f 00 49 stb r0,73(r31)
tty->termios.c_cc[VSTOP] = '\023';
ffc0695c: 38 00 00 13 li r0,19
/* 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;
ffc06960: 81 5f 00 64 lwz r10,100(r31)
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
ffc06964: 91 1f 00 3c stw r8,60(r31)
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
ffc06968: 39 00 00 03 li r8,3
/* 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;
ffc0696c: 55 4a f8 7e rlwinm r10,r10,31,1,31
tty->highwater = tty->rawInBuf.Size * 3/4;
ffc06970: 81 7f 00 64 lwz r11,100(r31)
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
ffc06974: 98 1f 00 4a stb r0,74(r31)
tty->termios.c_cc[VSUSP] = '\032';
ffc06978: 38 00 00 1a li r0,26
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;
ffc0697c: 1d 6b 00 03 mulli r11,r11,3
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
ffc06980: 99 1f 00 41 stb r8,65(r31)
tty->termios.c_cc[VQUIT] = '\034';
ffc06984: 39 00 00 1c li r8,28
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
ffc06988: 98 1f 00 4b stb r0,75(r31)
tty->termios.c_cc[VREPRINT] = '\022';
ffc0698c: 38 00 00 12 li r0,18
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;
ffc06990: 55 6b f0 be rlwinm r11,r11,30,2,31
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
ffc06994: 99 1f 00 42 stb r8,66(r31)
tty->termios.c_cc[VERASE] = '\177';
ffc06998: 39 00 00 7f li r8,127
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
ffc0699c: 98 1f 00 4d stb r0,77(r31)
tty->termios.c_cc[VDISCARD] = '\017';
ffc069a0: 38 00 00 0f li r0,15
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
ffc069a4: 99 1f 00 43 stb r8,67(r31)
tty->termios.c_cc[VKILL] = '\025';
ffc069a8: 39 00 00 15 li r8,21
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
ffc069ac: 98 1f 00 4e stb r0,78(r31)
tty->termios.c_cc[VWERASE] = '\027';
ffc069b0: 38 00 00 17 li r0,23
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
ffc069b4: 99 1f 00 44 stb r8,68(r31)
tty->termios.c_cc[VEOF] = '\004';
ffc069b8: 39 00 00 04 li r8,4
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
ffc069bc: 98 1f 00 4f stb r0,79(r31)
tty->termios.c_cc[VLNEXT] = '\026';
ffc069c0: 38 00 00 16 li r0,22
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';
ffc069c4: 99 1f 00 45 stb r8,69(r31)
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';
ffc069c8: 98 1f 00 50 stb r0,80(r31)
/* 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;
ffc069cc: 91 5f 00 bc stw r10,188(r31)
tty->highwater = tty->rawInBuf.Size * 3/4;
ffc069d0: 91 7f 00 c0 stw r11,192(r31)
/*
* Bump name characer
*/
if (c++ == 'z')
ffc069d4: 99 39 00 0c stb r9,12(r25)
ffc069d8: 40 9e fc d8 bne+ cr7,ffc066b0 <rtems_termios_open+0xac>
c = 'a';
ffc069dc: 38 00 00 61 li r0,97
ffc069e0: 98 19 00 0c stb r0,12(r25)
ffc069e4: 4b ff fc cc b ffc066b0 <rtems_termios_open+0xac>
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
if (tty->cbuf == NULL) {
free((void *)(tty->rawOutBuf.theBuf));
ffc069e8: 7e 83 a3 78 mr r3,r20 <== NOT EXECUTED
ffc069ec: 4b ff e7 b1 bl ffc0519c <free> <== NOT EXECUTED
free((void *)(tty->rawInBuf.theBuf));
ffc069f0: 7e a3 ab 78 mr r3,r21
ffc069f4: 4b ff e7 a9 bl ffc0519c <free>
free(tty);
ffc069f8: 7f e3 fb 78 mr r3,r31
ffc069fc: 4b ff e7 a1 bl ffc0519c <free>
rtems_semaphore_release (rtems_termios_ttyMutex);
ffc06a00: 80 7c 27 fc lwz r3,10236(r28)
return RTEMS_NO_MEMORY;
ffc06a04: 3b 60 00 1a li r27,26
tty->cbuf = malloc (CBUFSIZE);
if (tty->cbuf == NULL) {
free((void *)(tty->rawOutBuf.theBuf));
free((void *)(tty->rawInBuf.theBuf));
free(tty);
rtems_semaphore_release (rtems_termios_ttyMutex);
ffc06a08: 48 00 2b 5d bl ffc09564 <rtems_semaphore_release>
return RTEMS_NO_MEMORY;
ffc06a0c: 4b ff fc f4 b ffc06700 <rtems_termios_open+0xfc>
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'r', c),
ffc06a10: 88 79 00 0c lbz r3,12(r25)
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
ffc06a14: 38 80 00 00 li r4,0
ffc06a18: 38 a0 00 24 li r5,36
ffc06a1c: 64 63 54 52 oris r3,r3,21586
ffc06a20: 60 63 72 00 ori r3,r3,29184
ffc06a24: 38 c0 00 00 li r6,0
ffc06a28: 38 ff 00 68 addi r7,r31,104
ffc06a2c: 48 00 26 d5 bl ffc09100 <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)
ffc06a30: 2f 83 00 00 cmpwi cr7,r3,0
ffc06a34: 41 9e fe e4 beq+ cr7,ffc06918 <rtems_termios_open+0x314><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
ffc06a38: 48 00 33 09 bl ffc09d40 <rtems_fatal_error_occurred>
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
rtems_build_name ('T', 'x', 'T', c),
ffc06a3c: 88 79 00 0c lbz r3,12(r25)
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
ffc06a40: 38 80 00 0a li r4,10
ffc06a44: 38 a0 04 00 li r5,1024
ffc06a48: 64 63 54 78 oris r3,r3,21624
ffc06a4c: 60 63 54 00 ori r3,r3,21504
ffc06a50: 38 c0 05 00 li r6,1280
ffc06a54: 38 e0 00 00 li r7,0
ffc06a58: 39 1f 00 c8 addi r8,r31,200
ffc06a5c: 48 00 2b e9 bl ffc09644 <rtems_task_create>
TERMIOS_TXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
ffc06a60: 2f 83 00 00 cmpwi cr7,r3,0
ffc06a64: 40 be ff d4 bne- cr7,ffc06a38 <rtems_termios_open+0x434><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
rtems_build_name ('R', 'x', 'T', c),
ffc06a68: 88 79 00 0c lbz r3,12(r25)
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
ffc06a6c: 38 80 00 09 li r4,9
ffc06a70: 38 a0 04 00 li r5,1024
ffc06a74: 64 63 52 78 oris r3,r3,21112
ffc06a78: 60 63 54 00 ori r3,r3,21504
ffc06a7c: 38 c0 05 00 li r6,1280
ffc06a80: 38 e0 00 00 li r7,0
ffc06a84: 39 1f 00 c4 addi r8,r31,196
ffc06a88: 48 00 2b bd bl ffc09644 <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)
ffc06a8c: 2f 83 00 00 cmpwi cr7,r3,0
ffc06a90: 41 9e fe 70 beq+ cr7,ffc06900 <rtems_termios_open+0x2fc><== ALWAYS TAKEN
ffc06a94: 4b ff ff a4 b ffc06a38 <rtems_termios_open+0x434> <== NOT EXECUTED
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
ffc06a98: 93 e9 28 00 stw r31,10240(r9)
ffc06a9c: 4b ff fd 98 b ffc06834 <rtems_termios_open+0x230>
ffc07100 <rtems_termios_puts>:
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
ffc07100: 94 21 ff d0 stwu r1,-48(r1)
ffc07104: 7c 08 02 a6 mflr r0
ffc07108: 90 01 00 34 stw r0,52(r1)
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
ffc0710c: 80 05 00 b4 lwz r0,180(r5)
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
ffc07110: 93 41 00 18 stw r26,24(r1)
ffc07114: 7c 7a 1b 78 mr r26,r3
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
ffc07118: 2f 80 00 00 cmpwi cr7,r0,0
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
ffc0711c: 93 e1 00 2c stw r31,44(r1)
ffc07120: 7c bf 2b 78 mr r31,r5
ffc07124: 93 21 00 14 stw r25,20(r1)
ffc07128: 93 61 00 1c stw r27,28(r1)
ffc0712c: 93 81 00 20 stw r28,32(r1)
ffc07130: 93 a1 00 24 stw r29,36(r1)
ffc07134: 93 c1 00 28 stw r30,40(r1)
ffc07138: 90 81 00 08 stw r4,8(r1)
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
ffc0713c: 41 9e 01 2c beq- cr7,ffc07268 <rtems_termios_puts+0x168>
(*tty->device.write)(tty->minor, buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
ffc07140: 80 01 00 08 lwz r0,8(r1)
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
ffc07144: 83 65 00 80 lwz r27,128(r5)
while (len) {
ffc07148: 2f 80 00 00 cmpwi cr7,r0,0
ffc0714c: 41 9e 00 cc beq- cr7,ffc07218 <rtems_termios_puts+0x118><== NEVER TAKEN
/*
* Send characters to device-specific code
*/
void
rtems_termios_puts (
ffc07150: 3b 43 ff ff addi r26,r3,-1
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
ffc07154: 3b 80 00 02 li r28,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;
ffc07158: 3b 20 00 01 li r25,1
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
ffc0715c: 80 1f 00 88 lwz r0,136(r31)
ffc07160: 3b 7b 00 01 addi r27,r27,1
ffc07164: 7d 3b 03 96 divwu r9,r27,r0
ffc07168: 7c 09 01 d6 mullw r0,r9,r0
ffc0716c: 7f 60 d8 50 subf r27,r0,r27
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc07170: 7f c0 00 a6 mfmsr r30
ffc07174: 7c 10 42 a6 mfsprg r0,0
ffc07178: 7f c0 00 78 andc r0,r30,r0
ffc0717c: 7c 00 01 24 mtmsr r0
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
ffc07180: 83 bf 00 84 lwz r29,132(r31)
ffc07184: 7f 9d d8 00 cmpw cr7,r29,r27
ffc07188: 40 9e 00 40 bne- cr7,ffc071c8 <rtems_termios_puts+0xc8>
tty->rawOutBufState = rob_wait;
ffc0718c: 93 9f 00 94 stw r28,148(r31)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc07190: 7f c0 01 24 mtmsr r30
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
ffc07194: 80 7f 00 8c lwz r3,140(r31)
ffc07198: 38 80 00 00 li r4,0
ffc0719c: 38 a0 00 00 li r5,0
ffc071a0: 48 00 22 39 bl ffc093d8 <rtems_semaphore_obtain>
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc071a4: 2f 83 00 00 cmpwi cr7,r3,0
ffc071a8: 40 9e 01 04 bne- cr7,ffc072ac <rtems_termios_puts+0x1ac><== NEVER TAKEN
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc071ac: 7f c0 00 a6 mfmsr r30
ffc071b0: 7c 10 42 a6 mfsprg r0,0
ffc071b4: 7f c0 00 78 andc r0,r30,r0
ffc071b8: 7c 00 01 24 mtmsr r0
* 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) {
ffc071bc: 80 1f 00 84 lwz r0,132(r31)
ffc071c0: 7f 80 e8 00 cmpw cr7,r0,r29
ffc071c4: 41 9e ff c8 beq+ cr7,ffc0718c <rtems_termios_puts+0x8c> <== NEVER TAKEN
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++;
ffc071c8: 80 1f 00 80 lwz r0,128(r31)
ffc071cc: 8d 7a 00 01 lbzu r11,1(r26)
ffc071d0: 81 3f 00 7c lwz r9,124(r31)
ffc071d4: 7d 69 01 ae stbx r11,r9,r0
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
ffc071d8: 80 1f 00 94 lwz r0,148(r31)
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
tty->rawOutBuf.Head = newHead;
ffc071dc: 93 7f 00 80 stw r27,128(r31)
if (tty->rawOutBufState == rob_idle) {
ffc071e0: 2f 80 00 00 cmpwi cr7,r0,0
ffc071e4: 40 9e 00 20 bne- cr7,ffc07204 <rtems_termios_puts+0x104>
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
ffc071e8: 80 1f 00 b8 lwz r0,184(r31)
ffc071ec: 70 09 00 10 andi. r9,r0,16
ffc071f0: 41 82 00 54 beq- ffc07244 <rtems_termios_puts+0x144> <== ALWAYS TAKEN
(*tty->device.write)(tty->minor,
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
} else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
ffc071f4: 80 1f 00 b8 lwz r0,184(r31) <== NOT EXECUTED
ffc071f8: 60 00 00 20 ori r0,r0,32 <== NOT EXECUTED
ffc071fc: 90 1f 00 b8 stw r0,184(r31) <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
ffc07200: 93 3f 00 94 stw r25,148(r31)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc07204: 7f c0 01 24 mtmsr r30
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
ffc07208: 80 01 00 08 lwz r0,8(r1)
ffc0720c: 35 20 ff ff addic. r9,r0,-1
ffc07210: 91 21 00 08 stw r9,8(r1)
ffc07214: 40 82 ff 48 bne+ ffc0715c <rtems_termios_puts+0x5c>
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
ffc07218: 80 01 00 34 lwz r0,52(r1)
ffc0721c: 83 21 00 14 lwz r25,20(r1)
ffc07220: 7c 08 03 a6 mtlr r0
ffc07224: 83 41 00 18 lwz r26,24(r1)
ffc07228: 83 61 00 1c lwz r27,28(r1)
ffc0722c: 83 81 00 20 lwz r28,32(r1)
ffc07230: 83 a1 00 24 lwz r29,36(r1)
ffc07234: 83 c1 00 28 lwz r30,40(r1)
ffc07238: 83 e1 00 2c lwz r31,44(r1)
ffc0723c: 38 21 00 30 addi r1,r1,48
ffc07240: 4e 80 00 20 blr
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
(*tty->device.write)(tty->minor,
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
ffc07244: 81 3f 00 84 lwz r9,132(r31)
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,
ffc07248: 38 a0 00 01 li r5,1
ffc0724c: 80 9f 00 7c lwz r4,124(r31)
ffc07250: 80 1f 00 a4 lwz r0,164(r31)
ffc07254: 80 7f 00 10 lwz r3,16(r31)
ffc07258: 7c 84 4a 14 add r4,r4,r9
ffc0725c: 7c 09 03 a6 mtctr r0
ffc07260: 4e 80 04 21 bctrl
ffc07264: 4b ff ff 9c b ffc07200 <rtems_termios_puts+0x100>
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, buf, len);
ffc07268: 80 05 00 a4 lwz r0,164(r5)
ffc0726c: 7f 44 d3 78 mr r4,r26
ffc07270: 80 65 00 10 lwz r3,16(r5)
ffc07274: 7c 09 03 a6 mtctr r0
ffc07278: 80 a1 00 08 lwz r5,8(r1)
ffc0727c: 4e 80 04 21 bctrl
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
ffc07280: 80 01 00 34 lwz r0,52(r1)
ffc07284: 83 21 00 14 lwz r25,20(r1)
ffc07288: 7c 08 03 a6 mtlr r0
ffc0728c: 83 41 00 18 lwz r26,24(r1)
ffc07290: 83 61 00 1c lwz r27,28(r1)
ffc07294: 83 81 00 20 lwz r28,32(r1)
ffc07298: 83 a1 00 24 lwz r29,36(r1)
ffc0729c: 83 c1 00 28 lwz r30,40(r1)
ffc072a0: 83 e1 00 2c lwz r31,44(r1)
ffc072a4: 38 21 00 30 addi r1,r1,48
ffc072a8: 4e 80 00 20 blr
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
ffc072ac: 48 00 2a 95 bl ffc09d40 <rtems_fatal_error_occurred> <== NOT EXECUTED
ffc07b18 <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
ffc07b18: 94 21 ff d0 stwu r1,-48(r1)
ffc07b1c: 7c 08 02 a6 mflr r0
struct rtems_termios_tty *tty = args->iop->data1;
uint32_t count = args->count;
char *buffer = args->buffer;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
ffc07b20: 38 80 00 00 li r4,0
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
ffc07b24: 90 01 00 34 stw r0,52(r1)
struct rtems_termios_tty *tty = args->iop->data1;
uint32_t count = args->count;
char *buffer = args->buffer;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
ffc07b28: 38 a0 00 00 li r5,0
rtems_status_code
rtems_termios_read (void *arg)
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
ffc07b2c: 81 23 00 00 lwz r9,0(r3)
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
ffc07b30: 93 e1 00 2c stw r31,44(r1)
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
ffc07b34: 83 e9 00 38 lwz r31,56(r9)
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
ffc07b38: 93 41 00 18 stw r26,24(r1)
ffc07b3c: 7c 7a 1b 78 mr r26,r3
struct rtems_termios_tty *tty = args->iop->data1;
uint32_t count = args->count;
char *buffer = args->buffer;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
ffc07b40: 80 7f 00 14 lwz r3,20(r31)
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
ffc07b44: 93 01 00 10 stw r24,16(r1)
ffc07b48: 93 21 00 14 stw r25,20(r1)
ffc07b4c: 93 61 00 1c stw r27,28(r1)
ffc07b50: 92 c1 00 08 stw r22,8(r1)
ffc07b54: 92 e1 00 0c stw r23,12(r1)
ffc07b58: 93 81 00 20 stw r28,32(r1)
ffc07b5c: 93 a1 00 24 stw r29,36(r1)
ffc07b60: 93 c1 00 28 stw r30,40(r1)
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
uint32_t count = args->count;
ffc07b64: 83 7a 00 14 lwz r27,20(r26)
char *buffer = args->buffer;
ffc07b68: 83 1a 00 10 lwz r24,16(r26)
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
ffc07b6c: 48 00 18 6d bl ffc093d8 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
ffc07b70: 7c 79 1b 79 mr. r25,r3
ffc07b74: 40 82 00 48 bne- ffc07bbc <rtems_termios_read+0xa4> <== NEVER TAKEN
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
ffc07b78: 80 1f 00 cc lwz r0,204(r31)
ffc07b7c: 3d 20 00 00 lis r9,0
ffc07b80: 39 29 28 f0 addi r9,r9,10480
ffc07b84: 54 00 28 34 rlwinm r0,r0,5,0,26
ffc07b88: 7d 29 02 14 add r9,r9,r0
ffc07b8c: 80 09 00 08 lwz r0,8(r9)
ffc07b90: 2f 80 00 00 cmpwi cr7,r0,0
ffc07b94: 41 9e 00 64 beq- cr7,ffc07bf8 <rtems_termios_read+0xe0>
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
ffc07b98: 7c 09 03 a6 mtctr r0
ffc07b9c: 7f e3 fb 78 mr r3,r31
ffc07ba0: 7f 44 d3 78 mr r4,r26
ffc07ba4: 4e 80 04 21 bctrl
tty->tty_rcvwakeup = 0;
ffc07ba8: 38 00 00 00 li r0,0
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
ffc07bac: 7c 79 1b 78 mr r25,r3
tty->tty_rcvwakeup = 0;
ffc07bb0: 90 1f 00 e4 stw r0,228(r31)
rtems_semaphore_release (tty->isem);
ffc07bb4: 80 7f 00 14 lwz r3,20(r31)
ffc07bb8: 48 00 19 ad bl ffc09564 <rtems_semaphore_release>
}
args->bytes_moved = args->count - count;
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
ffc07bbc: 80 01 00 34 lwz r0,52(r1)
ffc07bc0: 7f 23 cb 78 mr r3,r25
ffc07bc4: 82 c1 00 08 lwz r22,8(r1)
ffc07bc8: 7c 08 03 a6 mtlr r0
ffc07bcc: 82 e1 00 0c lwz r23,12(r1)
ffc07bd0: 83 01 00 10 lwz r24,16(r1)
ffc07bd4: 83 21 00 14 lwz r25,20(r1)
ffc07bd8: 83 41 00 18 lwz r26,24(r1)
ffc07bdc: 83 61 00 1c lwz r27,28(r1)
ffc07be0: 83 81 00 20 lwz r28,32(r1)
ffc07be4: 83 a1 00 24 lwz r29,36(r1)
ffc07be8: 83 c1 00 28 lwz r30,40(r1)
ffc07bec: 83 e1 00 2c lwz r31,44(r1)
ffc07bf0: 38 21 00 30 addi r1,r1,48
ffc07bf4: 4e 80 00 20 blr
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
ffc07bf8: 81 3f 00 24 lwz r9,36(r31)
ffc07bfc: 80 1f 00 20 lwz r0,32(r31)
ffc07c00: 7f 89 00 00 cmpw cr7,r9,r0
ffc07c04: 41 9e 00 a8 beq- cr7,ffc07cac <rtems_termios_read+0x194><== ALWAYS TAKEN
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
ffc07c08: 2f 9b 00 00 cmpwi cr7,r27,0
ffc07c0c: 41 9e 00 48 beq- cr7,ffc07c54 <rtems_termios_read+0x13c><== NEVER TAKEN
ffc07c10: 81 3f 00 24 lwz r9,36(r31)
ffc07c14: 80 1f 00 20 lwz r0,32(r31)
ffc07c18: 7f 89 00 00 cmpw cr7,r9,r0
ffc07c1c: 40 9c 00 38 bge- cr7,ffc07c54 <rtems_termios_read+0x13c><== NEVER TAKEN
ffc07c20: 7f 09 c0 50 subf r24,r9,r24
ffc07c24: 7f 69 03 a6 mtctr r27
ffc07c28: 48 00 00 10 b ffc07c38 <rtems_termios_read+0x120>
ffc07c2c: 80 1f 00 20 lwz r0,32(r31)
ffc07c30: 7f 80 48 00 cmpw cr7,r0,r9
ffc07c34: 40 9d 00 20 ble- cr7,ffc07c54 <rtems_termios_read+0x13c>
*buffer++ = tty->cbuf[tty->cindex++];
ffc07c38: 81 7f 00 1c lwz r11,28(r31)
count--;
ffc07c3c: 3b 7b ff ff addi r27,r27,-1
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
ffc07c40: 7c 0b 48 ae lbzx r0,r11,r9
ffc07c44: 7c 18 49 ae stbx r0,r24,r9
ffc07c48: 39 29 00 01 addi r9,r9,1
ffc07c4c: 91 3f 00 24 stw r9,36(r31)
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
ffc07c50: 42 00 ff dc bdnz+ ffc07c2c <rtems_termios_read+0x114>
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
ffc07c54: 80 1a 00 14 lwz r0,20(r26)
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
ffc07c58: 80 7f 00 14 lwz r3,20(r31)
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
ffc07c5c: 7f 7b 00 50 subf r27,r27,r0
tty->tty_rcvwakeup = 0;
ffc07c60: 38 00 00 00 li r0,0
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
ffc07c64: 93 7a 00 1c stw r27,28(r26)
tty->tty_rcvwakeup = 0;
ffc07c68: 90 1f 00 e4 stw r0,228(r31)
rtems_semaphore_release (tty->isem);
ffc07c6c: 48 00 18 f9 bl ffc09564 <rtems_semaphore_release>
return sc;
}
ffc07c70: 80 01 00 34 lwz r0,52(r1)
ffc07c74: 7f 23 cb 78 mr r3,r25
ffc07c78: 82 c1 00 08 lwz r22,8(r1)
ffc07c7c: 7c 08 03 a6 mtlr r0
ffc07c80: 82 e1 00 0c lwz r23,12(r1)
ffc07c84: 83 01 00 10 lwz r24,16(r1)
ffc07c88: 83 21 00 14 lwz r25,20(r1)
ffc07c8c: 83 41 00 18 lwz r26,24(r1)
ffc07c90: 83 61 00 1c lwz r27,28(r1)
ffc07c94: 83 81 00 20 lwz r28,32(r1)
ffc07c98: 83 a1 00 24 lwz r29,36(r1)
ffc07c9c: 83 c1 00 28 lwz r30,40(r1)
ffc07ca0: 83 e1 00 2c lwz r31,44(r1)
ffc07ca4: 38 21 00 30 addi r1,r1,48
ffc07ca8: 4e 80 00 20 blr
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
tty->read_start_column = tty->column;
if (tty->device.pollRead != NULL &&
ffc07cac: 80 1f 00 a0 lwz r0,160(r31)
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
tty->read_start_column = tty->column;
ffc07cb0: 81 3f 00 28 lwz r9,40(r31)
if (tty->device.pollRead != NULL &&
ffc07cb4: 2f 80 00 00 cmpwi cr7,r0,0
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
ffc07cb8: 93 3f 00 20 stw r25,32(r31)
ffc07cbc: 93 3f 00 24 stw r25,36(r31)
tty->read_start_column = tty->column;
ffc07cc0: 91 3f 00 2c stw r9,44(r31)
if (tty->device.pollRead != NULL &&
ffc07cc4: 41 9e 00 10 beq- cr7,ffc07cd4 <rtems_termios_read+0x1bc>
ffc07cc8: 81 3f 00 b4 lwz r9,180(r31)
ffc07ccc: 2f 89 00 00 cmpwi cr7,r9,0
ffc07cd0: 41 9e 01 b4 beq- cr7,ffc07e84 <rtems_termios_read+0x36c>
* Fill the input buffer from the raw input queue
*/
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
ffc07cd4: 83 bf 00 74 lwz r29,116(r31)
rtems_status_code sc;
int wait = (int)1;
ffc07cd8: 3b c0 00 01 li r30,1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
(tty->ccount < (CBUFSIZE-1))) {
ffc07cdc: 3e e0 00 00 lis r23,0
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)(
ffc07ce0: 3a df 00 49 addi r22,r31,73
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
ffc07ce4: 81 3f 00 5c lwz r9,92(r31)
ffc07ce8: 80 1f 00 60 lwz r0,96(r31)
ffc07cec: 7f 89 00 00 cmpw cr7,r9,r0
ffc07cf0: 41 9e 01 3c beq- cr7,ffc07e2c <rtems_termios_read+0x314>
(tty->ccount < (CBUFSIZE-1))) {
ffc07cf4: 3b 97 21 b0 addi r28,r23,8624
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
ffc07cf8: 80 1f 00 20 lwz r0,32(r31)
(tty->ccount < (CBUFSIZE-1))) {
ffc07cfc: 81 3c 00 08 lwz r9,8(r28)
ffc07d00: 39 29 ff ff addi r9,r9,-1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
ffc07d04: 7f 89 00 00 cmpw cr7,r9,r0
ffc07d08: 41 bd 00 40 bgt+ cr7,ffc07d48 <rtems_termios_read+0x230><== ALWAYS TAKEN
ffc07d0c: 48 00 01 20 b ffc07e2c <rtems_termios_read+0x314> <== NOT EXECUTED
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
if (siproc (c, tty))
ffc07d10: 4b ff fc 59 bl ffc07968 <siproc>
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
ffc07d14: 81 3f 00 5c lwz r9,92(r31)
ffc07d18: 80 1f 00 60 lwz r0,96(r31)
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
if (siproc (c, tty))
wait = 0;
ffc07d1c: 30 63 ff ff addic r3,r3,-1
ffc07d20: 7c 63 19 10 subfe r3,r3,r3
} else {
siproc (c, tty);
if (tty->ccount >= tty->termios.c_cc[VMIN])
wait = 0;
}
timeout = tty->rawInBufSemaphoreTimeout;
ffc07d24: 83 bf 00 70 lwz r29,112(r31)
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
ffc07d28: 7f 89 00 00 cmpw cr7,r9,r0
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
if (siproc (c, tty))
wait = 0;
ffc07d2c: 7f de 18 38 and r30,r30,r3
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
ffc07d30: 41 9e 00 fc beq- cr7,ffc07e2c <rtems_termios_read+0x314>
(tty->ccount < (CBUFSIZE-1))) {
ffc07d34: 81 7c 00 08 lwz r11,8(r28)
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
ffc07d38: 81 3f 00 20 lwz r9,32(r31)
(tty->ccount < (CBUFSIZE-1))) {
ffc07d3c: 38 0b ff ff addi r0,r11,-1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
ffc07d40: 7f 89 00 00 cmpw cr7,r9,r0
ffc07d44: 40 9c 00 e8 bge- cr7,ffc07e2c <rtems_termios_read+0x314><== NEVER TAKEN
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
ffc07d48: 81 3f 00 5c lwz r9,92(r31)
ffc07d4c: 81 7f 00 64 lwz r11,100(r31)
ffc07d50: 39 29 00 01 addi r9,r9,1
c = tty->rawInBuf.theBuf[newHead];
ffc07d54: 81 1f 00 58 lwz r8,88(r31)
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;
ffc07d58: 7c 09 5b 96 divwu r0,r9,r11
c = tty->rawInBuf.theBuf[newHead];
tty->rawInBuf.Head = newHead;
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
ffc07d5c: 81 5f 00 bc lwz r10,188(r31)
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;
ffc07d60: 7c 00 59 d6 mullw r0,r0,r11
ffc07d64: 7c 00 48 50 subf r0,r0,r9
c = tty->rawInBuf.theBuf[newHead];
ffc07d68: 7f a8 00 ae lbzx r29,r8,r0
tty->rawInBuf.Head = newHead;
ffc07d6c: 90 1f 00 5c stw r0,92(r31)
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
ffc07d70: 81 7f 00 60 lwz r11,96(r31)
ffc07d74: 81 1f 00 64 lwz r8,100(r31)
% tty->rawInBuf.Size)
ffc07d78: 81 3f 00 64 lwz r9,100(r31)
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)
ffc07d7c: 7d 68 5a 14 add r11,r8,r11
ffc07d80: 7c 00 58 50 subf r0,r0,r11
% tty->rawInBuf.Size)
ffc07d84: 7d 60 4b 96 divwu r11,r0,r9
ffc07d88: 7d 2b 49 d6 mullw r9,r11,r9
ffc07d8c: 7c 09 00 50 subf r0,r9,r0
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)
ffc07d90: 7f 80 50 40 cmplw cr7,r0,r10
ffc07d94: 40 9c 00 50 bge- cr7,ffc07de4 <rtems_termios_read+0x2cc><== NEVER TAKEN
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
ffc07d98: 80 1f 00 b8 lwz r0,184(r31)
ffc07d9c: 54 00 00 3c rlwinm r0,r0,0,0,30
ffc07da0: 90 1f 00 b8 stw r0,184(r31)
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
ffc07da4: 80 1f 00 b8 lwz r0,184(r31)
ffc07da8: 70 00 02 02 andi. r0,r0,514
ffc07dac: 2f 80 02 02 cmpwi cr7,r0,514
ffc07db0: 41 9e 00 a0 beq- cr7,ffc07e50 <rtems_termios_read+0x338><== NEVER TAKEN
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
ffc07db4: 80 1f 00 b8 lwz r0,184(r31)
ffc07db8: 70 09 01 00 andi. r9,r0,256
ffc07dbc: 41 82 00 28 beq- ffc07de4 <rtems_termios_read+0x2cc> <== ALWAYS TAKEN
tty->flow_ctrl &= ~FL_IRTSOFF;
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
ffc07dc0: 80 1f 00 b0 lwz r0,176(r31) <== 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;
ffc07dc4: 81 3f 00 b8 lwz r9,184(r31) <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
ffc07dc8: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
tty->flow_ctrl &= ~FL_IRTSOFF;
ffc07dcc: 55 29 07 b8 rlwinm r9,r9,0,30,28 <== NOT EXECUTED
ffc07dd0: 91 3f 00 b8 stw r9,184(r31) <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
ffc07dd4: 41 9e 00 10 beq- cr7,ffc07de4 <rtems_termios_read+0x2cc><== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
ffc07dd8: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc07ddc: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc07de0: 4e 80 04 21 bctrl <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
ffc07de4: 80 1f 00 3c lwz r0,60(r31)
if (siproc (c, tty))
ffc07de8: 7f a3 eb 78 mr r3,r29
ffc07dec: 7f e4 fb 78 mr r4,r31
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
ffc07df0: 70 09 00 02 andi. r9,r0,2
ffc07df4: 40 a2 ff 1c bne- ffc07d10 <rtems_termios_read+0x1f8> <== ALWAYS TAKEN
if (siproc (c, tty))
wait = 0;
} else {
siproc (c, tty);
ffc07df8: 4b ff fb 71 bl ffc07968 <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
ffc07dfc: 88 1f 00 47 lbz r0,71(r31) <== NOT EXECUTED
ffc07e00: 81 3f 00 20 lwz r9,32(r31) <== NOT EXECUTED
wait = 0;
}
timeout = tty->rawInBufSemaphoreTimeout;
ffc07e04: 83 bf 00 70 lwz r29,112(r31) <== NOT EXECUTED
if (siproc (c, tty))
wait = 0;
} else {
siproc (c, tty);
if (tty->ccount >= tty->termios.c_cc[VMIN])
wait = 0;
ffc07e08: 7f 89 00 00 cmpw cr7,r9,r0 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
ffc07e0c: 81 3f 00 5c lwz r9,92(r31) <== NOT EXECUTED
if (siproc (c, tty))
wait = 0;
} else {
siproc (c, tty);
if (tty->ccount >= tty->termios.c_cc[VMIN])
wait = 0;
ffc07e10: 7c 00 00 26 mfcr r0 <== NOT EXECUTED
ffc07e14: 54 00 ef fe rlwinm r0,r0,29,31,31 <== NOT EXECUTED
ffc07e18: 7c 00 00 d0 neg r0,r0 <== NOT EXECUTED
ffc07e1c: 7f de 00 38 and r30,r30,r0 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
ffc07e20: 80 1f 00 60 lwz r0,96(r31) <== NOT EXECUTED
ffc07e24: 7f 89 00 00 cmpw cr7,r9,r0 <== NOT EXECUTED
ffc07e28: 40 9e ff 0c bne+ cr7,ffc07d34 <rtems_termios_read+0x21c><== NOT EXECUTED
}
/*
* Wait for characters
*/
if ( wait ) {
ffc07e2c: 2f 9e 00 00 cmpwi cr7,r30,0
ffc07e30: 41 9e fd d8 beq+ cr7,ffc07c08 <rtems_termios_read+0xf0>
sc = rtems_semaphore_obtain(
ffc07e34: 80 7f 00 68 lwz r3,104(r31)
ffc07e38: 7f a5 eb 78 mr r5,r29
ffc07e3c: 80 9f 00 6c lwz r4,108(r31)
ffc07e40: 48 00 15 99 bl ffc093d8 <rtems_semaphore_obtain>
tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
if (sc != RTEMS_SUCCESSFUL)
ffc07e44: 2f 83 00 00 cmpwi cr7,r3,0
ffc07e48: 41 9e fe 9c beq+ cr7,ffc07ce4 <rtems_termios_read+0x1cc><== ALWAYS TAKEN
ffc07e4c: 4b ff fd bc b ffc07c08 <rtems_termios_read+0xf0> <== NOT EXECUTED
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
ffc07e50: 80 1f 00 94 lwz r0,148(r31) <== NOT EXECUTED
ffc07e54: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc07e58: 41 9e 00 10 beq- cr7,ffc07e68 <rtems_termios_read+0x350><== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
ffc07e5c: 80 1f 00 b8 lwz r0,184(r31) <== NOT EXECUTED
ffc07e60: 70 09 00 20 andi. r9,r0,32 <== NOT EXECUTED
ffc07e64: 41 a2 ff 50 beq- ffc07db4 <rtems_termios_read+0x29c> <== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(
ffc07e68: 80 1f 00 a4 lwz r0,164(r31) <== NOT EXECUTED
ffc07e6c: 7e c4 b3 78 mr r4,r22 <== NOT EXECUTED
ffc07e70: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc07e74: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc07e78: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc07e7c: 4e 80 04 21 bctrl <== NOT EXECUTED
ffc07e80: 4b ff ff 64 b ffc07de4 <rtems_termios_read+0x2cc> <== NOT EXECUTED
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
ffc07e84: 81 3f 00 3c lwz r9,60(r31)
ffc07e88: 71 2b 00 02 andi. r11,r9,2
ffc07e8c: 41 82 00 34 beq- ffc07ec0 <rtems_termios_read+0x3a8>
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
ffc07e90: 80 7f 00 10 lwz r3,16(r31)
ffc07e94: 7c 09 03 a6 mtctr r0
ffc07e98: 4e 80 04 21 bctrl
if (n < 0) {
rtems_task_wake_after (1);
} else {
if (siproc (n, tty))
ffc07e9c: 7f e4 fb 78 mr r4,r31
int n;
if (tty->termios.c_lflag & ICANON) {
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
ffc07ea0: 2c 03 00 00 cmpwi r3,0
rtems_task_wake_after (1);
} else {
if (siproc (n, tty))
ffc07ea4: 54 63 06 3e clrlwi r3,r3,24
int n;
if (tty->termios.c_lflag & ICANON) {
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
ffc07ea8: 41 80 00 bc blt- ffc07f64 <rtems_termios_read+0x44c>
rtems_task_wake_after (1);
} else {
if (siproc (n, tty))
ffc07eac: 4b ff fa bd bl ffc07968 <siproc>
ffc07eb0: 2f 83 00 00 cmpwi cr7,r3,0
ffc07eb4: 40 be fd 54 bne- cr7,ffc07c08 <rtems_termios_read+0xf0>
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
ffc07eb8: 80 1f 00 a0 lwz r0,160(r31)
ffc07ebc: 4b ff ff d4 b ffc07e90 <rtems_termios_read+0x378>
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
ffc07ec0: 48 00 0d 31 bl ffc08bf0 <rtems_clock_get_ticks_since_boot>
ffc07ec4: 7c 7e 1b 78 mr r30,r3
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
ffc07ec8: 80 1f 00 a0 lwz r0,160(r31)
ffc07ecc: 80 7f 00 10 lwz r3,16(r31)
ffc07ed0: 7c 09 03 a6 mtctr r0
ffc07ed4: 4e 80 04 21 bctrl
if (n < 0) {
ffc07ed8: 2c 03 00 00 cmpwi r3,0
ffc07edc: 41 80 00 38 blt- ffc07f14 <rtems_termios_read+0x3fc>
break;
}
}
rtems_task_wake_after (1);
} else {
siproc (n, tty);
ffc07ee0: 54 63 06 3e clrlwi r3,r3,24
ffc07ee4: 7f e4 fb 78 mr r4,r31
ffc07ee8: 4b ff fa 81 bl ffc07968 <siproc>
if (tty->ccount >= tty->termios.c_cc[VMIN])
ffc07eec: 88 1f 00 47 lbz r0,71(r31)
ffc07ef0: 81 3f 00 20 lwz r9,32(r31)
ffc07ef4: 7f 89 00 00 cmpw cr7,r9,r0
ffc07ef8: 40 bc fd 10 bge- cr7,ffc07c08 <rtems_termios_read+0xf0>
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
ffc07efc: 2f 80 00 00 cmpwi cr7,r0,0
ffc07f00: 41 be ff c8 beq- cr7,ffc07ec8 <rtems_termios_read+0x3b0><== NEVER TAKEN
ffc07f04: 88 1f 00 46 lbz r0,70(r31)
ffc07f08: 2f 80 00 00 cmpwi cr7,r0,0
ffc07f0c: 41 9e ff bc beq+ cr7,ffc07ec8 <rtems_termios_read+0x3b0><== NEVER TAKEN
ffc07f10: 4b ff ff b0 b ffc07ec0 <rtems_termios_read+0x3a8>
then = rtems_clock_get_ticks_since_boot();
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
if (tty->termios.c_cc[VMIN]) {
ffc07f14: 88 1f 00 47 lbz r0,71(r31)
ffc07f18: 2f 80 00 00 cmpwi cr7,r0,0
if (tty->termios.c_cc[VTIME] && tty->ccount) {
ffc07f1c: 88 1f 00 46 lbz r0,70(r31)
then = rtems_clock_get_ticks_since_boot();
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
if (tty->termios.c_cc[VMIN]) {
ffc07f20: 41 9e 00 24 beq- cr7,ffc07f44 <rtems_termios_read+0x42c><== NEVER TAKEN
if (tty->termios.c_cc[VTIME] && tty->ccount) {
ffc07f24: 2f 80 00 00 cmpwi cr7,r0,0
ffc07f28: 41 9e 00 10 beq- cr7,ffc07f38 <rtems_termios_read+0x420><== NEVER TAKEN
ffc07f2c: 80 1f 00 20 lwz r0,32(r31)
ffc07f30: 2f 80 00 00 cmpwi cr7,r0,0
ffc07f34: 40 9e 00 18 bne- cr7,ffc07f4c <rtems_termios_read+0x434>
now = rtems_clock_get_ticks_since_boot();
if ((now - then) > tty->vtimeTicks) {
break;
}
}
rtems_task_wake_after (1);
ffc07f38: 38 60 00 01 li r3,1
ffc07f3c: 48 00 1b 75 bl ffc09ab0 <rtems_task_wake_after>
ffc07f40: 4b ff ff 88 b ffc07ec8 <rtems_termios_read+0x3b0>
if ((now - then) > tty->vtimeTicks) {
break;
}
}
} else {
if (!tty->termios.c_cc[VTIME])
ffc07f44: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc07f48: 41 be fc c0 beq- cr7,ffc07c08 <rtems_termios_read+0xf0> <== NOT EXECUTED
break;
now = rtems_clock_get_ticks_since_boot();
ffc07f4c: 48 00 0c a5 bl ffc08bf0 <rtems_clock_get_ticks_since_boot>
if ((now - then) > tty->vtimeTicks) {
ffc07f50: 80 1f 00 54 lwz r0,84(r31)
ffc07f54: 7c 7e 18 50 subf r3,r30,r3
ffc07f58: 7f 83 00 40 cmplw cr7,r3,r0
ffc07f5c: 40 9d ff dc ble+ cr7,ffc07f38 <rtems_termios_read+0x420>
ffc07f60: 4b ff fc a8 b ffc07c08 <rtems_termios_read+0xf0>
if (tty->termios.c_lflag & ICANON) {
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
rtems_task_wake_after (1);
ffc07f64: 38 60 00 01 li r3,1
ffc07f68: 48 00 1b 49 bl ffc09ab0 <rtems_task_wake_after>
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
ffc07f6c: 80 1f 00 a0 lwz r0,160(r31)
ffc07f70: 4b ff ff 20 b ffc07e90 <rtems_termios_read+0x378>
ffc083d4 <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)
{
ffc083d4: 94 21 ff e8 stwu r1,-24(r1)
ffc083d8: 7c 08 02 a6 mflr r0
ffc083dc: 90 01 00 1c stw r0,28(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))
ffc083e0: 80 03 00 b8 lwz r0,184(r3)
* 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)
{
ffc083e4: 93 e1 00 14 stw r31,20(r1)
ffc083e8: 7c 7f 1b 78 mr r31,r3
int nToSend;
rtems_interrupt_level level;
int len;
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
ffc083ec: 70 00 04 03 andi. r0,r0,1027
* 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)
{
ffc083f0: 93 a1 00 0c stw r29,12(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))
ffc083f4: 2f 80 04 01 cmpwi cr7,r0,1025
* 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)
{
ffc083f8: 93 c1 00 10 stw r30,16(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))
ffc083fc: 41 9e 01 5c beq- cr7,ffc08558 <rtems_termios_refill_transmitter+0x184><== NEVER TAKEN
tty->flow_ctrl |= FL_ISNTXOF;
rtems_interrupt_enable(level);
nToSend = 1;
} else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) {
ffc08400: 80 03 00 b8 lwz r0,184(r3)
ffc08404: 54 00 07 be clrlwi r0,r0,30
ffc08408: 2f 80 00 02 cmpwi cr7,r0,2
ffc0840c: 41 9e 01 b4 beq- cr7,ffc085c0 <rtems_termios_refill_transmitter+0x1ec><== NEVER TAKEN
tty->flow_ctrl &= ~FL_ISNTXOF;
rtems_interrupt_enable(level);
nToSend = 1;
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
ffc08410: 81 23 00 80 lwz r9,128(r3)
ffc08414: 80 03 00 84 lwz r0,132(r3)
ffc08418: 7f 89 00 00 cmpw cr7,r9,r0
ffc0841c: 41 9e 00 d8 beq- cr7,ffc084f4 <rtems_termios_refill_transmitter+0x120>
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc08420: 7c 00 00 a6 mfmsr r0
ffc08424: 7d 30 42 a6 mfsprg r9,0
ffc08428: 7c 09 48 78 andc r9,r0,r9
ffc0842c: 7d 20 01 24 mtmsr r9
return 0;
}
rtems_interrupt_disable(level);
len = tty->t_dqlen;
tty->t_dqlen = 0;
ffc08430: 39 20 00 00 li r9,0
}
return 0;
}
rtems_interrupt_disable(level);
len = tty->t_dqlen;
ffc08434: 83 c3 00 90 lwz r30,144(r3)
tty->t_dqlen = 0;
ffc08438: 91 23 00 90 stw r9,144(r3)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0843c: 7c 00 01 24 mtmsr r0
rtems_interrupt_enable(level);
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
ffc08440: 80 03 00 84 lwz r0,132(r3)
ffc08444: 81 23 00 88 lwz r9,136(r3)
ffc08448: 7c 1e 02 14 add r0,r30,r0
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
ffc0844c: 81 63 00 94 lwz r11,148(r3)
rtems_interrupt_disable(level);
len = tty->t_dqlen;
tty->t_dqlen = 0;
rtems_interrupt_enable(level);
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
ffc08450: 7f c0 4b 96 divwu r30,r0,r9
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
ffc08454: 2f 8b 00 02 cmpwi cr7,r11,2
rtems_interrupt_disable(level);
len = tty->t_dqlen;
tty->t_dqlen = 0;
rtems_interrupt_enable(level);
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
ffc08458: 7f de 49 d6 mullw r30,r30,r9
ffc0845c: 7f de 00 50 subf r30,r30,r0
tty->rawOutBuf.Tail = newTail;
ffc08460: 93 c3 00 84 stw r30,132(r3)
if (tty->rawOutBufState == rob_wait) {
ffc08464: 41 9e 00 e8 beq- cr7,ffc0854c <rtems_termios_refill_transmitter+0x178>
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
if (newTail == tty->rawOutBuf.Head) {
ffc08468: 80 1f 00 80 lwz r0,128(r31)
ffc0846c: 7f 80 f0 00 cmpw cr7,r0,r30
ffc08470: 41 9e 00 a0 beq- cr7,ffc08510 <rtems_termios_refill_transmitter+0x13c>
if ( tty->tty_snd.sw_pfn != NULL) {
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
}
}
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
ffc08474: 80 1f 00 b8 lwz r0,184(r31)
ffc08478: 70 00 02 10 andi. r0,r0,528
ffc0847c: 2f 80 02 10 cmpwi cr7,r0,528
ffc08480: 41 9e 01 7c beq- cr7,ffc085fc <rtems_termios_refill_transmitter+0x228><== NEVER TAKEN
nToSend = 0;
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
ffc08484: 80 1f 00 80 lwz r0,128(r31)
ffc08488: 7f 9e 00 40 cmplw cr7,r30,r0
ffc0848c: 41 9d 00 b4 bgt- cr7,ffc08540 <rtems_termios_refill_transmitter+0x16c>
nToSend = tty->rawOutBuf.Size - newTail;
else
nToSend = tty->rawOutBuf.Head - newTail;
ffc08490: 83 bf 00 80 lwz r29,128(r31)
ffc08494: 7f be e8 50 subf r29,r30,r29
/* 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)) {
ffc08498: 80 1f 00 b8 lwz r0,184(r31)
ffc0849c: 7f a5 eb 78 mr r5,r29
ffc084a0: 70 09 06 00 andi. r9,r0,1536
ffc084a4: 41 82 00 0c beq- ffc084b0 <rtems_termios_refill_transmitter+0xdc>
ffc084a8: 38 a0 00 01 li r5,1
nToSend = 1;
ffc084ac: 3b a0 00 01 li r29,1
}
tty->rawOutBufState = rob_busy; /*apm*/
ffc084b0: 38 00 00 01 li r0,1
(*tty->device.write)(
ffc084b4: 80 9f 00 7c lwz r4,124(r31)
/* 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*/
ffc084b8: 90 1f 00 94 stw r0,148(r31)
(*tty->device.write)(
ffc084bc: 7c 84 f2 14 add r4,r4,r30
ffc084c0: 80 1f 00 a4 lwz r0,164(r31)
ffc084c4: 80 7f 00 10 lwz r3,16(r31)
ffc084c8: 7c 09 03 a6 mtctr r0
ffc084cc: 4e 80 04 21 bctrl
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
ffc084d0: 93 df 00 84 stw r30,132(r31)
}
return nToSend;
}
ffc084d4: 80 01 00 1c lwz r0,28(r1)
ffc084d8: 7f a3 eb 78 mr r3,r29
ffc084dc: 83 c1 00 10 lwz r30,16(r1)
ffc084e0: 7c 08 03 a6 mtlr r0
ffc084e4: 83 a1 00 0c lwz r29,12(r1)
ffc084e8: 83 e1 00 14 lwz r31,20(r1)
ffc084ec: 38 21 00 18 addi r1,r1,24
ffc084f0: 4e 80 00 20 blr
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
ffc084f4: 80 03 00 94 lwz r0,148(r3)
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
return 0;
ffc084f8: 3b a0 00 00 li r29,0
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
ffc084fc: 2f 80 00 02 cmpwi cr7,r0,2
ffc08500: 40 9e ff d4 bne+ cr7,ffc084d4 <rtems_termios_refill_transmitter+0x100><== ALWAYS TAKEN
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
ffc08504: 80 63 00 8c lwz r3,140(r3) <== NOT EXECUTED
ffc08508: 48 00 10 5d bl ffc09564 <rtems_semaphore_release> <== NOT EXECUTED
ffc0850c: 4b ff ff c8 b ffc084d4 <rtems_termios_refill_transmitter+0x100><== NOT EXECUTED
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
ffc08510: 80 1f 00 d4 lwz r0,212(r31)
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
ffc08514: 39 20 00 00 li r9,0
ffc08518: 91 3f 00 94 stw r9,148(r31)
nToSend = 0;
ffc0851c: 3b a0 00 00 li r29,0
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
ffc08520: 2f 80 00 00 cmpwi cr7,r0,0
ffc08524: 41 be ff ac beq- cr7,ffc084d0 <rtems_termios_refill_transmitter+0xfc><== ALWAYS TAKEN
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
ffc08528: 38 7f 00 30 addi r3,r31,48 <== NOT EXECUTED
ffc0852c: 80 9f 00 d8 lwz r4,216(r31) <== NOT EXECUTED
ffc08530: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc08534: 4e 80 04 21 bctrl <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy; /*apm*/
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
ffc08538: 93 df 00 84 stw r30,132(r31) <== NOT EXECUTED
ffc0853c: 4b ff ff 98 b ffc084d4 <rtems_termios_refill_transmitter+0x100><== NOT EXECUTED
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
nToSend = tty->rawOutBuf.Size - newTail;
ffc08540: 83 bf 00 88 lwz r29,136(r31)
ffc08544: 7f be e8 50 subf r29,r30,r29
ffc08548: 4b ff ff 50 b ffc08498 <rtems_termios_refill_transmitter+0xc4>
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
ffc0854c: 80 63 00 8c lwz r3,140(r3)
ffc08550: 48 00 10 15 bl ffc09564 <rtems_semaphore_release>
ffc08554: 4b ff ff 14 b ffc08468 <rtems_termios_refill_transmitter+0x94>
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
ffc08558: 80 03 00 a4 lwz r0,164(r3) <== NOT EXECUTED
ffc0855c: 38 9f 00 4a addi r4,r31,74 <== NOT EXECUTED
ffc08560: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc08564: 80 63 00 10 lwz r3,16(r3) <== NOT EXECUTED
ffc08568: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc0856c: 4e 80 04 21 bctrl <== NOT EXECUTED
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc08570: 7c 00 00 a6 mfmsr r0 <== NOT EXECUTED
ffc08574: 7d 30 42 a6 mfsprg r9,0 <== NOT EXECUTED
ffc08578: 7c 09 48 78 andc r9,r0,r9 <== NOT EXECUTED
ffc0857c: 7d 20 01 24 mtmsr r9 <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->t_dqlen--;
ffc08580: 81 7f 00 90 lwz r11,144(r31) <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
ffc08584: 81 3f 00 b8 lwz r9,184(r31) <== NOT EXECUTED
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
ffc08588: 39 6b ff ff addi r11,r11,-1 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
ffc0858c: 61 29 00 02 ori r9,r9,2 <== NOT EXECUTED
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
ffc08590: 91 7f 00 90 stw r11,144(r31) <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
ffc08594: 91 3f 00 b8 stw r9,184(r31) <== NOT EXECUTED
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc08598: 7c 00 01 24 mtmsr r0 <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
ffc0859c: 80 01 00 1c lwz r0,28(r1) <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->t_dqlen--;
tty->flow_ctrl &= ~FL_ISNTXOF;
rtems_interrupt_enable(level);
nToSend = 1;
ffc085a0: 3b a0 00 01 li r29,1 <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
ffc085a4: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc085a8: 83 c1 00 10 lwz r30,16(r1) <== NOT EXECUTED
ffc085ac: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc085b0: 83 a1 00 0c lwz r29,12(r1) <== NOT EXECUTED
ffc085b4: 83 e1 00 14 lwz r31,20(r1) <== NOT EXECUTED
ffc085b8: 38 21 00 18 addi r1,r1,24 <== NOT EXECUTED
ffc085bc: 4e 80 00 20 blr <== NOT EXECUTED
* FIXME: this .write call will generate another
* dequeue callback. This will advance the "Tail" in the data
* buffer, although the corresponding data is not yet out!
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
ffc085c0: 80 03 00 a4 lwz r0,164(r3) <== NOT EXECUTED
ffc085c4: 38 9f 00 49 addi r4,r31,73 <== NOT EXECUTED
ffc085c8: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc085cc: 80 63 00 10 lwz r3,16(r3) <== NOT EXECUTED
ffc085d0: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc085d4: 4e 80 04 21 bctrl <== NOT EXECUTED
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc085d8: 7c 00 00 a6 mfmsr r0 <== NOT EXECUTED
ffc085dc: 7d 30 42 a6 mfsprg r9,0 <== NOT EXECUTED
ffc085e0: 7c 09 48 78 andc r9,r0,r9 <== NOT EXECUTED
ffc085e4: 7d 20 01 24 mtmsr r9 <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->t_dqlen--;
ffc085e8: 81 7f 00 90 lwz r11,144(r31) <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
ffc085ec: 81 3f 00 b8 lwz r9,184(r31) <== 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--;
ffc085f0: 39 6b ff ff addi r11,r11,-1 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
ffc085f4: 55 29 07 fa rlwinm r9,r9,0,31,29 <== NOT EXECUTED
ffc085f8: 4b ff ff 98 b ffc08590 <rtems_termios_refill_transmitter+0x1bc><== NOT EXECUTED
ffc085fc: 7c 00 00 a6 mfmsr r0 <== NOT EXECUTED
ffc08600: 7d 30 42 a6 mfsprg r9,0 <== NOT EXECUTED
ffc08604: 7c 09 48 78 andc r9,r0,r9 <== NOT EXECUTED
ffc08608: 7d 20 01 24 mtmsr r9 <== NOT EXECUTED
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
== (FL_MDXON | FL_ORCVXOF)) {
/* Buffer not empty, but output stops due to XOFF */
/* set flag, that output has been stopped */
rtems_interrupt_disable(level);
tty->flow_ctrl |= FL_OSTOP;
ffc0860c: 81 3f 00 b8 lwz r9,184(r31) <== NOT EXECUTED
ffc08610: 61 29 00 20 ori r9,r9,32 <== NOT EXECUTED
ffc08614: 91 3f 00 b8 stw r9,184(r31) <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
ffc08618: 39 20 00 01 li r9,1 <== NOT EXECUTED
ffc0861c: 91 3f 00 94 stw r9,148(r31) <== NOT EXECUTED
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc08620: 7c 00 01 24 mtmsr r0 <== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 0;
ffc08624: 3b a0 00 00 li r29,0 <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy; /*apm*/
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
ffc08628: 93 df 00 84 stw r30,132(r31) <== NOT EXECUTED
ffc0862c: 4b ff fe a8 b ffc084d4 <rtems_termios_refill_transmitter+0x100><== NOT EXECUTED
ffc0833c <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
ffc0833c: 94 21 ff e0 stwu r1,-32(r1)
ffc08340: 7c 08 02 a6 mflr r0
ffc08344: 93 e1 00 1c stw r31,28(r1)
ffc08348: 7c 7f 1b 78 mr r31,r3
ffc0834c: 90 01 00 24 stw r0,36(r1)
ffc08350: 48 00 00 20 b ffc08370 <rtems_termios_rxdaemon+0x34>
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
ffc08354: 80 1f 00 a0 lwz r0,160(r31)
ffc08358: 80 7f 00 10 lwz r3,16(r31)
ffc0835c: 7c 09 03 a6 mtctr r0
ffc08360: 4e 80 04 21 bctrl
if (c != EOF) {
ffc08364: 2f 83 ff ff cmpwi cr7,r3,-1
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
ffc08368: 7c 60 1b 78 mr r0,r3
if (c != EOF) {
ffc0836c: 40 9e 00 50 bne- cr7,ffc083bc <rtems_termios_rxdaemon+0x80>
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
ffc08370: 38 c1 00 0c addi r6,r1,12
ffc08374: 38 80 00 02 li r4,2
ffc08378: 38 a0 00 00 li r5,0
ffc0837c: 38 60 00 03 li r3,3
ffc08380: 48 00 08 fd bl ffc08c7c <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) {
ffc08384: 80 01 00 0c lwz r0,12(r1)
ffc08388: 70 09 00 01 andi. r9,r0,1
ffc0838c: 41 82 ff c8 beq+ ffc08354 <rtems_termios_rxdaemon+0x18> <== ALWAYS TAKEN
tty->rxTaskId = 0;
ffc08390: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc08394: 90 1f 00 c4 stw r0,196(r31) <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
ffc08398: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc0839c: 48 00 14 21 bl ffc097bc <rtems_task_delete> <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
ffc083a0: 80 1f 00 a0 lwz r0,160(r31) <== NOT EXECUTED
ffc083a4: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc083a8: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc083ac: 4e 80 04 21 bctrl <== NOT EXECUTED
if (c != EOF) {
ffc083b0: 2f 83 ff ff cmpwi cr7,r3,-1 <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
ffc083b4: 7c 60 1b 78 mr r0,r3 <== NOT EXECUTED
if (c != EOF) {
ffc083b8: 41 9e ff b8 beq+ cr7,ffc08370 <rtems_termios_rxdaemon+0x34><== NOT EXECUTED
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
ffc083bc: 7f e3 fb 78 mr r3,r31
c = tty->device.pollRead(tty->minor);
if (c != EOF) {
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
ffc083c0: 98 01 00 08 stb r0,8(r1)
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
ffc083c4: 38 81 00 08 addi r4,r1,8
ffc083c8: 38 a0 00 01 li r5,1
ffc083cc: 4b ff fb d1 bl ffc07f9c <rtems_termios_enqueue_raw_characters>
ffc083d0: 4b ff ff a0 b ffc08370 <rtems_termios_rxdaemon+0x34>
ffc08630 <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
ffc08630: 94 21 ff e0 stwu r1,-32(r1)
ffc08634: 7c 08 02 a6 mflr r0
ffc08638: 93 c1 00 18 stw r30,24(r1)
ffc0863c: 3f c0 00 00 lis r30,0
ffc08640: 3b de 28 f0 addi r30,r30,10480
ffc08644: 93 e1 00 1c stw r31,28(r1)
ffc08648: 7c 7f 1b 78 mr r31,r3
ffc0864c: 90 01 00 24 stw r0,36(r1)
ffc08650: 48 00 00 30 b ffc08680 <rtems_termios_txdaemon+0x50>
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
ffc08654: 81 3f 00 cc lwz r9,204(r31)
rtems_termios_linesw[tty->t_line].l_start(tty);
ffc08658: 7f e3 fb 78 mr r3,r31
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
ffc0865c: 55 29 28 34 rlwinm r9,r9,5,0,26
ffc08660: 7d 3e 4a 14 add r9,r30,r9
ffc08664: 80 09 00 14 lwz r0,20(r9)
ffc08668: 2f 80 00 00 cmpwi cr7,r0,0
ffc0866c: 41 9e 00 0c beq- cr7,ffc08678 <rtems_termios_txdaemon+0x48><== ALWAYS TAKEN
rtems_termios_linesw[tty->t_line].l_start(tty);
ffc08670: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc08674: 4e 80 04 21 bctrl <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
ffc08678: 7f e3 fb 78 mr r3,r31
ffc0867c: 4b ff fd 59 bl ffc083d4 <rtems_termios_refill_transmitter>
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
ffc08680: 38 80 00 02 li r4,2
ffc08684: 38 a0 00 00 li r5,0
ffc08688: 38 c1 00 08 addi r6,r1,8
ffc0868c: 38 60 00 03 li r3,3
ffc08690: 48 00 05 ed bl ffc08c7c <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) {
ffc08694: 80 01 00 08 lwz r0,8(r1)
ffc08698: 70 09 00 01 andi. r9,r0,1
ffc0869c: 41 82 ff b8 beq+ ffc08654 <rtems_termios_txdaemon+0x24> <== ALWAYS TAKEN
tty->txTaskId = 0;
ffc086a0: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc086a4: 90 1f 00 c8 stw r0,200(r31) <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
ffc086a8: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc086ac: 48 00 11 11 bl ffc097bc <rtems_task_delete> <== NOT EXECUTED
ffc086b0: 4b ff ff a4 b ffc08654 <rtems_termios_txdaemon+0x24> <== NOT EXECUTED
ffc079ec <rtems_termios_write>:
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
ffc079ec: 94 21 ff e0 stwu r1,-32(r1)
ffc079f0: 7c 08 02 a6 mflr r0
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
ffc079f4: 38 80 00 00 li r4,0
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
ffc079f8: 90 01 00 24 stw r0,36(r1)
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
ffc079fc: 38 a0 00 00 li r5,0
rtems_status_code
rtems_termios_write (void *arg)
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
ffc07a00: 81 23 00 00 lwz r9,0(r3)
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
ffc07a04: 93 e1 00 1c stw r31,28(r1)
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
ffc07a08: 83 e9 00 38 lwz r31,56(r9)
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
ffc07a0c: 93 c1 00 18 stw r30,24(r1)
ffc07a10: 7c 7e 1b 78 mr r30,r3
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
ffc07a14: 80 7f 00 18 lwz r3,24(r31)
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
ffc07a18: 93 a1 00 14 stw r29,20(r1)
ffc07a1c: 93 81 00 10 stw r28,16(r1)
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
ffc07a20: 48 00 19 b9 bl ffc093d8 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
ffc07a24: 7c 7d 1b 79 mr. r29,r3
ffc07a28: 40 82 00 40 bne- ffc07a68 <rtems_termios_write+0x7c> <== NEVER TAKEN
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
ffc07a2c: 80 1f 00 cc lwz r0,204(r31)
ffc07a30: 3d 20 00 00 lis r9,0
ffc07a34: 39 29 28 f0 addi r9,r9,10480
ffc07a38: 54 00 28 34 rlwinm r0,r0,5,0,26
ffc07a3c: 7d 29 02 14 add r9,r9,r0
ffc07a40: 80 09 00 0c lwz r0,12(r9)
ffc07a44: 2f 80 00 00 cmpwi cr7,r0,0
ffc07a48: 41 9e 00 44 beq- cr7,ffc07a8c <rtems_termios_write+0xa0>
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
ffc07a4c: 7f e3 fb 78 mr r3,r31
ffc07a50: 7c 09 03 a6 mtctr r0
ffc07a54: 7f c4 f3 78 mr r4,r30
ffc07a58: 4e 80 04 21 bctrl
ffc07a5c: 7c 7d 1b 78 mr r29,r3
rtems_semaphore_release (tty->osem);
ffc07a60: 80 7f 00 18 lwz r3,24(r31)
ffc07a64: 48 00 1b 01 bl ffc09564 <rtems_semaphore_release>
rtems_termios_puts (args->buffer, args->count, tty);
args->bytes_moved = args->count;
}
rtems_semaphore_release (tty->osem);
return sc;
}
ffc07a68: 80 01 00 24 lwz r0,36(r1)
ffc07a6c: 7f a3 eb 78 mr r3,r29
ffc07a70: 83 81 00 10 lwz r28,16(r1)
ffc07a74: 7c 08 03 a6 mtlr r0
ffc07a78: 83 a1 00 14 lwz r29,20(r1)
ffc07a7c: 83 c1 00 18 lwz r30,24(r1)
ffc07a80: 83 e1 00 1c lwz r31,28(r1)
ffc07a84: 38 21 00 20 addi r1,r1,32
ffc07a88: 4e 80 00 20 blr
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) {
ffc07a8c: 80 1f 00 34 lwz r0,52(r31)
ffc07a90: 70 09 00 01 andi. r9,r0,1
ffc07a94: 41 82 00 70 beq- ffc07b04 <rtems_termios_write+0x118> <== NEVER TAKEN
uint32_t count = args->count;
ffc07a98: 80 1e 00 14 lwz r0,20(r30)
char *buffer = args->buffer;
ffc07a9c: 83 9e 00 10 lwz r28,16(r30)
while (count--)
ffc07aa0: 2f 80 00 00 cmpwi cr7,r0,0
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
rtems_semaphore_release (tty->osem);
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
ffc07aa4: 90 01 00 08 stw r0,8(r1)
char *buffer = args->buffer;
while (count--)
ffc07aa8: 38 00 00 00 li r0,0
ffc07aac: 41 9e 00 28 beq- cr7,ffc07ad4 <rtems_termios_write+0xe8><== NEVER TAKEN
}
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
ffc07ab0: 3b 9c ff ff addi r28,r28,-1
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
oproc (*buffer++, tty);
ffc07ab4: 8c 7c 00 01 lbzu r3,1(r28)
ffc07ab8: 7f e4 fb 78 mr r4,r31
ffc07abc: 4b ff f7 f5 bl ffc072b0 <oproc>
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
ffc07ac0: 80 01 00 08 lwz r0,8(r1)
ffc07ac4: 35 20 ff ff addic. r9,r0,-1
ffc07ac8: 91 21 00 08 stw r9,8(r1)
ffc07acc: 40 82 ff e8 bne+ ffc07ab4 <rtems_termios_write+0xc8>
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
args->bytes_moved = args->count;
ffc07ad0: 80 1e 00 14 lwz r0,20(r30)
ffc07ad4: 90 1e 00 1c stw r0,28(r30)
}
rtems_semaphore_release (tty->osem);
ffc07ad8: 80 7f 00 18 lwz r3,24(r31)
ffc07adc: 48 00 1a 89 bl ffc09564 <rtems_semaphore_release>
return sc;
}
ffc07ae0: 80 01 00 24 lwz r0,36(r1)
ffc07ae4: 7f a3 eb 78 mr r3,r29
ffc07ae8: 83 81 00 10 lwz r28,16(r1)
ffc07aec: 7c 08 03 a6 mtlr r0
ffc07af0: 83 a1 00 14 lwz r29,20(r1)
ffc07af4: 83 c1 00 18 lwz r30,24(r1)
ffc07af8: 83 e1 00 1c lwz r31,28(r1)
ffc07afc: 38 21 00 20 addi r1,r1,32
ffc07b00: 4e 80 00 20 blr
char *buffer = args->buffer;
while (count--)
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
ffc07b04: 80 7e 00 10 lwz r3,16(r30) <== NOT EXECUTED
ffc07b08: 7f e5 fb 78 mr r5,r31 <== NOT EXECUTED
ffc07b0c: 80 9e 00 14 lwz r4,20(r30) <== NOT EXECUTED
ffc07b10: 4b ff f5 f1 bl ffc07100 <rtems_termios_puts> <== NOT EXECUTED
ffc07b14: 4b ff ff bc b ffc07ad0 <rtems_termios_write+0xe4> <== NOT EXECUTED
ffc1bb78 <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
ffc1bb78: 94 21 ff e8 stwu r1,-24(r1)
ffc1bb7c: 7c 08 02 a6 mflr r0
ffc1bb80: 7c 64 1b 78 mr r4,r3
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
ffc1bb84: 3c 60 00 00 lis r3,0
ffc1bb88: 90 01 00 1c stw r0,28(r1)
ffc1bb8c: 38 63 79 9c addi r3,r3,31132
ffc1bb90: 38 a1 00 08 addi r5,r1,8
ffc1bb94: 48 00 3d 2d bl ffc1f8c0 <_Objects_Get>
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
ffc1bb98: 80 01 00 08 lwz r0,8(r1)
ffc1bb9c: 2f 80 00 00 cmpwi cr7,r0,0
ffc1bba0: 40 9e 00 30 bne- cr7,ffc1bbd0 <rtems_timer_cancel+0x58>
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
ffc1bba4: 80 03 00 38 lwz r0,56(r3)
ffc1bba8: 2f 80 00 04 cmpwi cr7,r0,4
ffc1bbac: 41 9e 00 0c beq- cr7,ffc1bbb8 <rtems_timer_cancel+0x40> <== NEVER TAKEN
(void) _Watchdog_Remove( &the_timer->Ticker );
ffc1bbb0: 38 63 00 10 addi r3,r3,16
ffc1bbb4: 48 00 66 4d bl ffc22200 <_Watchdog_Remove>
_Thread_Enable_dispatch();
ffc1bbb8: 48 00 4d e9 bl ffc209a0 <_Thread_Enable_dispatch>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
ffc1bbbc: 80 01 00 1c lwz r0,28(r1)
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
(void) _Watchdog_Remove( &the_timer->Ticker );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
ffc1bbc0: 38 60 00 00 li r3,0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
ffc1bbc4: 7c 08 03 a6 mtlr r0
ffc1bbc8: 38 21 00 18 addi r1,r1,24
ffc1bbcc: 4e 80 00 20 blr
ffc1bbd0: 80 01 00 1c lwz r0,28(r1)
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
ffc1bbd4: 38 60 00 04 li r3,4
}
ffc1bbd8: 38 21 00 18 addi r1,r1,24
ffc1bbdc: 7c 08 03 a6 mtlr r0
ffc1bbe0: 4e 80 00 20 blr
ffc1c234 <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
ffc1c234: 94 21 ff c0 stwu r1,-64(r1)
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
ffc1c238: 3d 20 00 00 lis r9,0
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
ffc1c23c: 7c 08 02 a6 mflr r0
ffc1c240: 93 e1 00 3c stw r31,60(r1)
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
ffc1c244: 83 e9 29 34 lwz r31,10548(r9)
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
ffc1c248: 93 41 00 28 stw r26,40(r1)
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
ffc1c24c: 3b 40 00 0e li r26,14
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
ffc1c250: 2f 9f 00 00 cmpwi cr7,r31,0
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
ffc1c254: 93 a1 00 34 stw r29,52(r1)
ffc1c258: 7c 7d 1b 78 mr r29,r3
ffc1c25c: 93 c1 00 38 stw r30,56(r1)
ffc1c260: 7c be 2b 78 mr r30,r5
ffc1c264: 90 01 00 44 stw r0,68(r1)
ffc1c268: 93 21 00 24 stw r25,36(r1)
ffc1c26c: 93 61 00 2c stw r27,44(r1)
ffc1c270: 93 81 00 30 stw r28,48(r1)
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
ffc1c274: 41 9e 00 18 beq- cr7,ffc1c28c <rtems_timer_server_fire_when+0x58>
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
ffc1c278: 3d 20 00 00 lis r9,0
ffc1c27c: 88 09 28 e4 lbz r0,10468(r9)
return RTEMS_NOT_DEFINED;
ffc1c280: 3b 40 00 0b li r26,11
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
ffc1c284: 2f 80 00 00 cmpwi cr7,r0,0
ffc1c288: 40 9e 00 34 bne- cr7,ffc1c2bc <rtems_timer_server_fire_when+0x88><== ALWAYS TAKEN
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
ffc1c28c: 80 01 00 44 lwz r0,68(r1)
ffc1c290: 7f 43 d3 78 mr r3,r26
ffc1c294: 83 21 00 24 lwz r25,36(r1)
ffc1c298: 7c 08 03 a6 mtlr r0
ffc1c29c: 83 41 00 28 lwz r26,40(r1)
ffc1c2a0: 83 61 00 2c lwz r27,44(r1)
ffc1c2a4: 83 81 00 30 lwz r28,48(r1)
ffc1c2a8: 83 a1 00 34 lwz r29,52(r1)
ffc1c2ac: 83 c1 00 38 lwz r30,56(r1)
ffc1c2b0: 83 e1 00 3c lwz r31,60(r1)
ffc1c2b4: 38 21 00 40 addi r1,r1,64
ffc1c2b8: 4e 80 00 20 blr
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
ffc1c2bc: 2f 85 00 00 cmpwi cr7,r5,0
return RTEMS_INVALID_ADDRESS;
ffc1c2c0: 3b 40 00 09 li r26,9
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
ffc1c2c4: 41 be ff c8 beq- cr7,ffc1c28c <rtems_timer_server_fire_when+0x58>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
ffc1c2c8: 7c 83 23 78 mr r3,r4
ffc1c2cc: 90 81 00 18 stw r4,24(r1)
return RTEMS_INVALID_CLOCK;
ffc1c2d0: 3b 40 00 14 li r26,20
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
ffc1c2d4: 90 c1 00 1c stw r6,28(r1)
ffc1c2d8: 4b ff c0 49 bl ffc18320 <_TOD_Validate>
ffc1c2dc: 2f 83 00 00 cmpwi cr7,r3,0
ffc1c2e0: 80 81 00 18 lwz r4,24(r1)
ffc1c2e4: 41 9e ff a8 beq+ cr7,ffc1c28c <rtems_timer_server_fire_when+0x58>
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
ffc1c2e8: 7c 83 23 78 mr r3,r4
if ( seconds <= _TOD_Seconds_since_epoch() )
ffc1c2ec: 3f 60 00 00 lis r27,0
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
ffc1c2f0: 4b ff bf 95 bl ffc18284 <_TOD_To_seconds>
if ( seconds <= _TOD_Seconds_since_epoch() )
ffc1c2f4: 80 1b 28 f8 lwz r0,10488(r27)
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
ffc1c2f8: 7c 7c 1b 78 mr r28,r3
if ( seconds <= _TOD_Seconds_since_epoch() )
ffc1c2fc: 7f 83 00 40 cmplw cr7,r3,r0
ffc1c300: 40 9d ff 8c ble+ cr7,ffc1c28c <rtems_timer_server_fire_when+0x58>
ffc1c304: 3c 60 00 00 lis r3,0
ffc1c308: 38 63 79 9c addi r3,r3,31132
ffc1c30c: 7f a4 eb 78 mr r4,r29
ffc1c310: 38 a1 00 08 addi r5,r1,8
ffc1c314: 48 00 35 ad bl ffc1f8c0 <_Objects_Get>
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
ffc1c318: 83 21 00 08 lwz r25,8(r1)
ffc1c31c: 7c 7a 1b 78 mr r26,r3
ffc1c320: 2f 99 00 00 cmpwi cr7,r25,0
ffc1c324: 40 9e 00 54 bne- cr7,ffc1c378 <rtems_timer_server_fire_when+0x144>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
ffc1c328: 38 63 00 10 addi r3,r3,16
ffc1c32c: 48 00 5e d5 bl ffc22200 <_Watchdog_Remove>
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();
ffc1c330: 80 1b 28 f8 lwz r0,10488(r27)
ffc1c334: 80 c1 00 1c lwz r6,28(r1)
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
ffc1c338: 39 20 00 03 li r9,3
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
ffc1c33c: 7f 80 e0 50 subf r28,r0,r28
(*timer_server->schedule_operation)( timer_server, the_timer );
ffc1c340: 80 1f 00 04 lwz r0,4(r31)
ffc1c344: 7f 44 d3 78 mr r4,r26
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
ffc1c348: 91 3a 00 38 stw r9,56(r26)
_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 );
ffc1c34c: 7f e3 fb 78 mr r3,r31
ffc1c350: 7c 09 03 a6 mtctr r0
ffc1c354: 90 da 00 34 stw r6,52(r26)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
ffc1c358: 93 3a 00 18 stw r25,24(r26)
the_watchdog->routine = routine;
ffc1c35c: 93 da 00 2c stw r30,44(r26)
the_watchdog->id = id;
ffc1c360: 93 ba 00 30 stw r29,48(r26)
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();
ffc1c364: 93 9a 00 1c stw r28,28(r26)
(*timer_server->schedule_operation)( timer_server, the_timer );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
ffc1c368: 3b 40 00 00 li r26,0
(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();
(*timer_server->schedule_operation)( timer_server, the_timer );
ffc1c36c: 4e 80 04 21 bctrl
_Thread_Enable_dispatch();
ffc1c370: 48 00 46 31 bl ffc209a0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
ffc1c374: 4b ff ff 18 b ffc1c28c <rtems_timer_server_fire_when+0x58>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
ffc1c378: 3b 40 00 04 li r26,4
ffc1c37c: 4b ff ff 10 b ffc1c28c <rtems_timer_server_fire_when+0x58>
ffc04c3c <rtems_verror>:
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
ffc04c3c: 94 21 ff e0 stwu r1,-32(r1)
ffc04c40: 7c 08 02 a6 mflr r0
ffc04c44: 90 01 00 24 stw r0,36(r1)
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
ffc04c48: 74 60 20 00 andis. r0,r3,8192
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
ffc04c4c: 93 41 00 08 stw r26,8(r1)
ffc04c50: 7c 9a 23 78 mr r26,r4
ffc04c54: 93 61 00 0c stw r27,12(r1)
ffc04c58: 7c bb 2b 78 mr r27,r5
ffc04c5c: 93 c1 00 18 stw r30,24(r1)
ffc04c60: 7c 7e 1b 78 mr r30,r3
ffc04c64: 93 81 00 10 stw r28,16(r1)
ffc04c68: 93 a1 00 14 stw r29,20(r1)
ffc04c6c: 93 e1 00 1c stw r31,28(r1)
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
ffc04c70: 41 82 00 40 beq- ffc04cb0 <rtems_verror+0x74>
if (rtems_panic_in_progress++)
ffc04c74: 3d 20 00 00 lis r9,0
ffc04c78: 81 69 27 ec lwz r11,10220(r9)
ffc04c7c: 2f 8b 00 00 cmpwi cr7,r11,0
ffc04c80: 38 0b 00 01 addi r0,r11,1
ffc04c84: 90 09 27 ec stw r0,10220(r9)
ffc04c88: 41 9e 00 1c beq- cr7,ffc04ca4 <rtems_verror+0x68> <== ALWAYS TAKEN
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc04c8c: 3d 60 00 00 lis r11,0 <== NOT EXECUTED
ffc04c90: 81 4b 28 0c lwz r10,10252(r11) <== NOT EXECUTED
ffc04c94: 38 0a 00 01 addi r0,r10,1 <== NOT EXECUTED
ffc04c98: 90 0b 28 0c stw r0,10252(r11) <== NOT EXECUTED
return _Thread_Dispatch_disable_level;
ffc04c9c: 80 0b 28 0c lwz r0,10252(r11) <== NOT EXECUTED
void _Thread_Disable_dispatch( void );
#else
RTEMS_INLINE_ROUTINE void _Thread_Disable_dispatch( void )
{
_Thread_Dispatch_increment_disable_level();
RTEMS_COMPILER_MEMORY_BARRIER();
ffc04ca0: 80 09 27 ec lwz r0,10220(r9) <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
ffc04ca4: 2f 80 00 02 cmpwi cr7,r0,2
return 0;
ffc04ca8: 3b a0 00 00 li r29,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)
ffc04cac: 41 9d 00 ac bgt- cr7,ffc04d58 <rtems_verror+0x11c> <== NEVER TAKEN
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
ffc04cb0: 3f e0 00 00 lis r31,0
ffc04cb4: 81 3f 27 8c lwz r9,10124(r31)
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
int local_errno = 0;
ffc04cb8: 3b 80 00 00 li r28,0
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
ffc04cbc: 80 69 00 08 lwz r3,8(r9)
ffc04cc0: 48 00 f5 a1 bl ffc14260 <fflush>
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
ffc04cc4: 77 c0 40 00 andis. r0,r30,16384
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
status = error_flag & ~RTEMS_ERROR_MASK;
ffc04cc8: 57 de 01 00 rlwinm r30,r30,0,4,0
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
ffc04ccc: 40 82 00 ec bne- ffc04db8 <rtems_verror+0x17c>
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
ffc04cd0: 81 3f 27 8c lwz r9,10124(r31)
ffc04cd4: 7f 44 d3 78 mr r4,r26
ffc04cd8: 7f 65 db 78 mr r5,r27
ffc04cdc: 80 69 00 0c lwz r3,12(r9)
ffc04ce0: 48 01 4c 91 bl ffc19970 <vfprintf>
if (status)
ffc04ce4: 2f 9e 00 00 cmpwi cr7,r30,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);
ffc04ce8: 7c 7d 1b 78 mr r29,r3
if (status)
ffc04cec: 40 9e 00 98 bne- cr7,ffc04d84 <rtems_verror+0x148>
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
ffc04cf0: 2f 9c 00 00 cmpwi cr7,r28,0
ffc04cf4: 41 9e 00 3c beq- cr7,ffc04d30 <rtems_verror+0xf4>
if ((local_errno > 0) && *strerror(local_errno))
ffc04cf8: 40 9d 00 18 ble- cr7,ffc04d10 <rtems_verror+0xd4>
ffc04cfc: 7f 83 e3 78 mr r3,r28
ffc04d00: 48 01 09 a1 bl ffc156a0 <strerror>
ffc04d04: 88 03 00 00 lbz r0,0(r3)
ffc04d08: 2f 80 00 00 cmpwi cr7,r0,0
ffc04d0c: 40 9e 00 b8 bne- cr7,ffc04dc4 <rtems_verror+0x188> <== ALWAYS TAKEN
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
ffc04d10: 81 3f 27 8c lwz r9,10124(r31)
ffc04d14: 3c 80 ff c2 lis r4,-62
ffc04d18: 38 84 08 94 addi r4,r4,2196
ffc04d1c: 80 69 00 0c lwz r3,12(r9)
ffc04d20: 7f 85 e3 78 mr r5,r28
ffc04d24: 4c c6 31 82 crclr 4*cr1+eq
ffc04d28: 48 00 fa f1 bl ffc14818 <fprintf>
ffc04d2c: 7f bd 1a 14 add r29,r29,r3
}
chars_written += fprintf(stderr, "\n");
ffc04d30: 81 3f 27 8c lwz r9,10124(r31)
ffc04d34: 3c 80 ff c2 lis r4,-62
ffc04d38: 38 84 fb 04 addi r4,r4,-1276
ffc04d3c: 80 69 00 0c lwz r3,12(r9)
ffc04d40: 4c c6 31 82 crclr 4*cr1+eq
ffc04d44: 48 00 fa d5 bl ffc14818 <fprintf>
(void) fflush(stderr);
ffc04d48: 81 3f 27 8c lwz r9,10124(r31)
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
}
chars_written += fprintf(stderr, "\n");
ffc04d4c: 7f a3 ea 14 add r29,r3,r29
(void) fflush(stderr);
ffc04d50: 80 69 00 0c lwz r3,12(r9)
ffc04d54: 48 00 f5 0d bl ffc14260 <fflush>
return chars_written;
}
ffc04d58: 80 01 00 24 lwz r0,36(r1)
ffc04d5c: 7f a3 eb 78 mr r3,r29
ffc04d60: 83 41 00 08 lwz r26,8(r1)
ffc04d64: 7c 08 03 a6 mtlr r0
ffc04d68: 83 61 00 0c lwz r27,12(r1)
ffc04d6c: 83 81 00 10 lwz r28,16(r1)
ffc04d70: 83 a1 00 14 lwz r29,20(r1)
ffc04d74: 83 c1 00 18 lwz r30,24(r1)
ffc04d78: 83 e1 00 1c lwz r31,28(r1)
ffc04d7c: 38 21 00 20 addi r1,r1,32
ffc04d80: 4e 80 00 20 blr
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
ffc04d84: 3d 20 00 00 lis r9,0
ffc04d88: 81 29 27 8c lwz r9,10124(r9)
ffc04d8c: 7f c3 f3 78 mr r3,r30
ffc04d90: 83 c9 00 0c lwz r30,12(r9)
ffc04d94: 4b ff fe 7d bl ffc04c10 <rtems_status_text>
ffc04d98: 3c 80 ff c2 lis r4,-62
ffc04d9c: 7c 65 1b 78 mr r5,r3
ffc04da0: 38 84 08 74 addi r4,r4,2164
ffc04da4: 7f c3 f3 78 mr r3,r30
ffc04da8: 4c c6 31 82 crclr 4*cr1+eq
ffc04dac: 48 00 fa 6d bl ffc14818 <fprintf>
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
ffc04db0: 7f bd 1a 14 add r29,r29,r3
ffc04db4: 4b ff ff 3c b ffc04cf0 <rtems_verror+0xb4>
(void) fflush(stdout); /* in case stdout/stderr same */
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
local_errno = errno;
ffc04db8: 48 00 ef d5 bl ffc13d8c <__errno>
ffc04dbc: 83 83 00 00 lwz r28,0(r3)
ffc04dc0: 4b ff ff 10 b ffc04cd0 <rtems_verror+0x94>
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
if ((local_errno > 0) && *strerror(local_errno))
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
ffc04dc4: 81 3f 27 8c lwz r9,10124(r31)
ffc04dc8: 7f 83 e3 78 mr r3,r28
ffc04dcc: 83 c9 00 0c lwz r30,12(r9)
ffc04dd0: 48 01 08 d1 bl ffc156a0 <strerror>
ffc04dd4: 3c 80 ff c2 lis r4,-62
ffc04dd8: 7c 65 1b 78 mr r5,r3
ffc04ddc: 38 84 08 84 addi r4,r4,2180
ffc04de0: 7f c3 f3 78 mr r3,r30
ffc04de4: 4c c6 31 82 crclr 4*cr1+eq
ffc04de8: 48 00 fa 31 bl ffc14818 <fprintf>
ffc04dec: 7f bd 1a 14 add r29,r29,r3
ffc04df0: 4b ff ff 40 b ffc04d30 <rtems_verror+0xf4>
ffc05448 <scanInt>:
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
ffc05448: 94 21 ff d8 stwu r1,-40(r1)
ffc0544c: 7c 08 02 a6 mflr r0
ffc05450: 93 41 00 10 stw r26,16(r1)
sign = 1;
}
if (!isdigit(c))
return 0;
d = c - '0';
if ((i > (limit / 10))
ffc05454: 3f 40 cc cc lis r26,-13108
ffc05458: 63 5a cc cd ori r26,r26,52429
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
ffc0545c: 93 81 00 18 stw r28,24(r1)
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
ffc05460: 3f 80 7f ff lis r28,32767
ffc05464: 63 9c ff ff ori r28,r28,65535
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
ffc05468: 90 01 00 2c stw r0,44(r1)
ffc0546c: 93 01 00 08 stw r24,8(r1)
ffc05470: 7c 98 23 78 mr r24,r4
ffc05474: 93 21 00 0c stw r25,12(r1)
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
ffc05478: 3f 20 00 00 lis r25,0
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
ffc0547c: 93 61 00 14 stw r27,20(r1)
limit++;
continue;
}
sign = 1;
}
if (!isdigit(c))
ffc05480: 3f 60 00 00 lis r27,0
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
ffc05484: 93 a1 00 1c stw r29,28(r1)
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
int sign = 0;
ffc05488: 3b a0 00 00 li r29,0
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
ffc0548c: 93 c1 00 20 stw r30,32(r1)
int c;
unsigned int i = 0;
ffc05490: 3b c0 00 00 li r30,0
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
ffc05494: 93 e1 00 24 stw r31,36(r1)
ffc05498: 7c 7f 1b 78 mr r31,r3
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
ffc0549c: 81 3f 00 04 lwz r9,4(r31)
ffc054a0: 38 09 ff ff addi r0,r9,-1
ffc054a4: 2f 80 00 00 cmpwi cr7,r0,0
ffc054a8: 90 1f 00 04 stw r0,4(r31)
ffc054ac: 41 9c 00 7c blt- cr7,ffc05528 <scanInt+0xe0> <== NEVER TAKEN
ffc054b0: 81 3f 00 00 lwz r9,0(r31)
ffc054b4: 88 69 00 00 lbz r3,0(r9)
ffc054b8: 38 09 00 01 addi r0,r9,1
ffc054bc: 90 1f 00 00 stw r0,0(r31)
if (c == ':')
ffc054c0: 2f 83 00 3a cmpwi cr7,r3,58
ffc054c4: 41 9e 00 78 beq- cr7,ffc0553c <scanInt+0xf4>
break;
if (sign == 0) {
ffc054c8: 2f 9d 00 00 cmpwi cr7,r29,0
ffc054cc: 40 9e 00 10 bne- cr7,ffc054dc <scanInt+0x94>
if (c == '-') {
ffc054d0: 2f 83 00 2d cmpwi cr7,r3,45
sign = -1;
limit++;
continue;
}
sign = 1;
ffc054d4: 3b a0 00 01 li r29,1
for (;;) {
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
ffc054d8: 41 9e 00 ec beq- cr7,ffc055c4 <scanInt+0x17c>
limit++;
continue;
}
sign = 1;
}
if (!isdigit(c))
ffc054dc: 81 3b 27 64 lwz r9,10084(r27)
ffc054e0: 7d 29 1a 14 add r9,r9,r3
ffc054e4: 88 09 00 01 lbz r0,1(r9)
ffc054e8: 70 09 00 04 andi. r9,r0,4
ffc054ec: 41 82 00 a4 beq- ffc05590 <scanInt+0x148>
return 0;
d = c - '0';
if ((i > (limit / 10))
ffc054f0: 7c 1c d0 16 mulhwu r0,r28,r26
ffc054f4: 54 00 e8 fe rlwinm r0,r0,29,3,31
ffc054f8: 7f 9e 00 40 cmplw cr7,r30,r0
ffc054fc: 41 9d 00 94 bgt- cr7,ffc05590 <scanInt+0x148>
|| ((i == (limit / 10)) && (d > (limit % 10))))
ffc05500: 7f 9e 00 00 cmpw cr7,r30,r0
}
sign = 1;
}
if (!isdigit(c))
return 0;
d = c - '0';
ffc05504: 38 63 ff d0 addi r3,r3,-48
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
ffc05508: 1f de 00 0a mulli r30,r30,10
ffc0550c: 41 9e 00 78 beq- cr7,ffc05584 <scanInt+0x13c>
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
ffc05510: 81 3f 00 04 lwz r9,4(r31)
return 0;
d = c - '0';
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
ffc05514: 7f c3 f2 14 add r30,r3,r30
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
ffc05518: 38 09 ff ff addi r0,r9,-1
ffc0551c: 2f 80 00 00 cmpwi cr7,r0,0
ffc05520: 90 1f 00 04 stw r0,4(r31)
ffc05524: 40 9c ff 8c bge+ cr7,ffc054b0 <scanInt+0x68> <== ALWAYS TAKEN
ffc05528: 80 79 27 6c lwz r3,10092(r25) <== NOT EXECUTED
ffc0552c: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc05530: 48 01 10 e1 bl ffc16610 <__srget_r> <== NOT EXECUTED
if (c == ':')
ffc05534: 2f 83 00 3a cmpwi cr7,r3,58 <== NOT EXECUTED
ffc05538: 40 9e ff 90 bne+ cr7,ffc054c8 <scanInt+0x80> <== NOT EXECUTED
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
}
if (sign == 0)
ffc0553c: 2f 9d 00 00 cmpwi cr7,r29,0
return 0;
ffc05540: 38 60 00 00 li r3,0
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
}
if (sign == 0)
ffc05544: 41 9e 00 50 beq- cr7,ffc05594 <scanInt+0x14c> <== NEVER TAKEN
return 0;
*val = i * sign;
return 1;
}
ffc05548: 80 01 00 2c lwz r0,44(r1)
return 0;
i = i * 10 + d;
}
if (sign == 0)
return 0;
*val = i * sign;
ffc0554c: 7f dd f1 d6 mullw r30,r29,r30
return 1;
}
ffc05550: 83 21 00 0c lwz r25,12(r1)
ffc05554: 7c 08 03 a6 mtlr r0
i = i * 10 + d;
}
if (sign == 0)
return 0;
*val = i * sign;
return 1;
ffc05558: 38 60 00 01 li r3,1
return 0;
i = i * 10 + d;
}
if (sign == 0)
return 0;
*val = i * sign;
ffc0555c: 93 d8 00 00 stw r30,0(r24)
return 1;
}
ffc05560: 83 01 00 08 lwz r24,8(r1)
ffc05564: 83 41 00 10 lwz r26,16(r1)
ffc05568: 83 61 00 14 lwz r27,20(r1)
ffc0556c: 83 81 00 18 lwz r28,24(r1)
ffc05570: 83 a1 00 1c lwz r29,28(r1)
ffc05574: 83 c1 00 20 lwz r30,32(r1)
ffc05578: 83 e1 00 24 lwz r31,36(r1)
ffc0557c: 38 21 00 28 addi r1,r1,40
ffc05580: 4e 80 00 20 blr
}
if (!isdigit(c))
return 0;
d = c - '0';
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
ffc05584: 7c 1e e0 50 subf r0,r30,r28
ffc05588: 7f 83 00 40 cmplw cr7,r3,r0
ffc0558c: 40 9d ff 84 ble+ cr7,ffc05510 <scanInt+0xc8> <== NEVER TAKEN
return 0;
ffc05590: 38 60 00 00 li r3,0
}
if (sign == 0)
return 0;
*val = i * sign;
return 1;
}
ffc05594: 80 01 00 2c lwz r0,44(r1)
ffc05598: 83 01 00 08 lwz r24,8(r1)
ffc0559c: 7c 08 03 a6 mtlr r0
ffc055a0: 83 21 00 0c lwz r25,12(r1)
ffc055a4: 83 41 00 10 lwz r26,16(r1)
ffc055a8: 83 61 00 14 lwz r27,20(r1)
ffc055ac: 83 81 00 18 lwz r28,24(r1)
ffc055b0: 83 a1 00 1c lwz r29,28(r1)
ffc055b4: 83 c1 00 20 lwz r30,32(r1)
ffc055b8: 83 e1 00 24 lwz r31,36(r1)
ffc055bc: 38 21 00 28 addi r1,r1,40
ffc055c0: 4e 80 00 20 blr
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
sign = -1;
limit++;
ffc055c4: 3b 9c 00 01 addi r28,r28,1
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
sign = -1;
ffc055c8: 3b a0 ff ff li r29,-1
limit++;
continue;
ffc055cc: 4b ff fe d0 b ffc0549c <scanInt+0x54>
ffc055d0 <scanString>:
/*
* Extract a string value from the database
*/
static int
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{
ffc055d0: 94 21 ff e0 stwu r1,-32(r1)
ffc055d4: 7c 08 02 a6 mflr r0
ffc055d8: 90 01 00 24 stw r0,36(r1)
int c;
*name = *bufp;
ffc055dc: 80 05 00 00 lwz r0,0(r5)
/*
* Extract a string value from the database
*/
static int
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{
ffc055e0: 93 61 00 0c stw r27,12(r1)
ffc055e4: 7c fb 3b 78 mr r27,r7
ffc055e8: 93 81 00 10 stw r28,16(r1)
int c;
*name = *bufp;
for (;;) {
c = getc(fp);
ffc055ec: 3f 80 00 00 lis r28,0
/*
* Extract a string value from the database
*/
static int
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{
ffc055f0: 93 a1 00 14 stw r29,20(r1)
ffc055f4: 7c dd 33 78 mr r29,r6
ffc055f8: 93 c1 00 18 stw r30,24(r1)
ffc055fc: 7c be 2b 78 mr r30,r5
ffc05600: 93 e1 00 1c stw r31,28(r1)
ffc05604: 7c 7f 1b 78 mr r31,r3
int c;
*name = *bufp;
ffc05608: 90 04 00 00 stw r0,0(r4)
ffc0560c: 48 00 00 58 b ffc05664 <scanString+0x94>
for (;;) {
c = getc(fp);
ffc05610: 81 3f 00 00 lwz r9,0(r31)
ffc05614: 88 69 00 00 lbz r3,0(r9)
ffc05618: 38 09 00 01 addi r0,r9,1
ffc0561c: 90 1f 00 00 stw r0,0(r31)
if (c == ':') {
ffc05620: 2f 83 00 3a cmpwi cr7,r3,58
if (nlFlag)
return 0;
break;
}
if (c == '\n') {
ffc05624: 2f 03 00 0a cmpwi cr6,r3,10
if (!nlFlag)
return 0;
break;
}
if (c == EOF)
ffc05628: 2c 83 ff ff cmpwi cr1,r3,-1
int c;
*name = *bufp;
for (;;) {
c = getc(fp);
if (c == ':') {
ffc0562c: 41 9e 00 68 beq- cr7,ffc05694 <scanString+0xc4>
if (nlFlag)
return 0;
break;
}
if (c == '\n') {
ffc05630: 41 9a 00 e4 beq- cr6,ffc05714 <scanString+0x144>
if (!nlFlag)
return 0;
break;
}
if (c == EOF)
ffc05634: 41 86 00 b8 beq- cr1,ffc056ec <scanString+0x11c>
return 0;
if (*nleft < 2)
ffc05638: 80 1d 00 00 lwz r0,0(r29)
ffc0563c: 2b 80 00 01 cmplwi cr7,r0,1
ffc05640: 40 9d 00 ac ble- cr7,ffc056ec <scanString+0x11c>
return 0;
**bufp = c;
ffc05644: 81 3e 00 00 lwz r9,0(r30)
ffc05648: 98 69 00 00 stb r3,0(r9)
++(*bufp);
ffc0564c: 81 3e 00 00 lwz r9,0(r30)
--(*nleft);
ffc05650: 81 7d 00 00 lwz r11,0(r29)
if (c == EOF)
return 0;
if (*nleft < 2)
return 0;
**bufp = c;
++(*bufp);
ffc05654: 39 29 00 01 addi r9,r9,1
--(*nleft);
ffc05658: 38 0b ff ff addi r0,r11,-1
if (c == EOF)
return 0;
if (*nleft < 2)
return 0;
**bufp = c;
++(*bufp);
ffc0565c: 91 3e 00 00 stw r9,0(r30)
--(*nleft);
ffc05660: 90 1d 00 00 stw r0,0(r29)
{
int c;
*name = *bufp;
for (;;) {
c = getc(fp);
ffc05664: 81 3f 00 04 lwz r9,4(r31)
ffc05668: 38 09 ff ff addi r0,r9,-1
ffc0566c: 2f 80 00 00 cmpwi cr7,r0,0
ffc05670: 90 1f 00 04 stw r0,4(r31)
ffc05674: 40 9c ff 9c bge+ cr7,ffc05610 <scanString+0x40>
ffc05678: 80 7c 27 6c lwz r3,10092(r28)
ffc0567c: 7f e4 fb 78 mr r4,r31
ffc05680: 48 01 0f 91 bl ffc16610 <__srget_r>
if (c == ':') {
ffc05684: 2f 83 00 3a cmpwi cr7,r3,58
if (nlFlag)
return 0;
break;
}
if (c == '\n') {
ffc05688: 2f 03 00 0a cmpwi cr6,r3,10
if (!nlFlag)
return 0;
break;
}
if (c == EOF)
ffc0568c: 2c 83 ff ff cmpwi cr1,r3,-1
int c;
*name = *bufp;
for (;;) {
c = getc(fp);
if (c == ':') {
ffc05690: 40 9e ff a0 bne+ cr7,ffc05630 <scanString+0x60> <== ALWAYS TAKEN
if (nlFlag)
ffc05694: 2f 9b 00 00 cmpwi cr7,r27,0
return 0;
ffc05698: 38 60 00 00 li r3,0
*name = *bufp;
for (;;) {
c = getc(fp);
if (c == ':') {
if (nlFlag)
ffc0569c: 40 9e 00 54 bne- cr7,ffc056f0 <scanString+0x120>
return 0;
**bufp = c;
++(*bufp);
--(*nleft);
}
**bufp = '\0';
ffc056a0: 81 3e 00 00 lwz r9,0(r30)
ffc056a4: 38 00 00 00 li r0,0
++(*bufp);
--(*nleft);
return 1;
ffc056a8: 38 60 00 01 li r3,1
return 0;
**bufp = c;
++(*bufp);
--(*nleft);
}
**bufp = '\0';
ffc056ac: 98 09 00 00 stb r0,0(r9)
++(*bufp);
ffc056b0: 81 3e 00 00 lwz r9,0(r30)
--(*nleft);
ffc056b4: 81 7d 00 00 lwz r11,0(r29)
**bufp = c;
++(*bufp);
--(*nleft);
}
**bufp = '\0';
++(*bufp);
ffc056b8: 39 29 00 01 addi r9,r9,1
--(*nleft);
ffc056bc: 38 0b ff ff addi r0,r11,-1
**bufp = c;
++(*bufp);
--(*nleft);
}
**bufp = '\0';
++(*bufp);
ffc056c0: 91 3e 00 00 stw r9,0(r30)
--(*nleft);
ffc056c4: 90 1d 00 00 stw r0,0(r29)
return 1;
}
ffc056c8: 80 01 00 24 lwz r0,36(r1)
ffc056cc: 83 61 00 0c lwz r27,12(r1)
ffc056d0: 7c 08 03 a6 mtlr r0
ffc056d4: 83 81 00 10 lwz r28,16(r1)
ffc056d8: 83 a1 00 14 lwz r29,20(r1)
ffc056dc: 83 c1 00 18 lwz r30,24(r1)
ffc056e0: 83 e1 00 1c lwz r31,28(r1)
ffc056e4: 38 21 00 20 addi r1,r1,32
ffc056e8: 4e 80 00 20 blr
break;
}
if (c == EOF)
return 0;
if (*nleft < 2)
return 0;
ffc056ec: 38 60 00 00 li r3,0
}
**bufp = '\0';
++(*bufp);
--(*nleft);
return 1;
}
ffc056f0: 80 01 00 24 lwz r0,36(r1)
ffc056f4: 83 61 00 0c lwz r27,12(r1)
ffc056f8: 7c 08 03 a6 mtlr r0
ffc056fc: 83 81 00 10 lwz r28,16(r1)
ffc05700: 83 a1 00 14 lwz r29,20(r1)
ffc05704: 83 c1 00 18 lwz r30,24(r1)
ffc05708: 83 e1 00 1c lwz r31,28(r1)
ffc0570c: 38 21 00 20 addi r1,r1,32
ffc05710: 4e 80 00 20 blr
if (nlFlag)
return 0;
break;
}
if (c == '\n') {
if (!nlFlag)
ffc05714: 2f 9b 00 00 cmpwi cr7,r27,0
return 0;
ffc05718: 38 60 00 00 li r3,0
if (nlFlag)
return 0;
break;
}
if (c == '\n') {
if (!nlFlag)
ffc0571c: 41 be ff d4 beq- cr7,ffc056f0 <scanString+0x120>
return 0;
**bufp = c;
++(*bufp);
--(*nleft);
}
**bufp = '\0';
ffc05720: 81 3e 00 00 lwz r9,0(r30)
ffc05724: 38 00 00 00 li r0,0
++(*bufp);
--(*nleft);
return 1;
ffc05728: 38 60 00 01 li r3,1
return 0;
**bufp = c;
++(*bufp);
--(*nleft);
}
**bufp = '\0';
ffc0572c: 98 09 00 00 stb r0,0(r9)
++(*bufp);
ffc05730: 81 3e 00 00 lwz r9,0(r30)
--(*nleft);
ffc05734: 81 7d 00 00 lwz r11,0(r29)
**bufp = c;
++(*bufp);
--(*nleft);
}
**bufp = '\0';
++(*bufp);
ffc05738: 39 29 00 01 addi r9,r9,1
--(*nleft);
ffc0573c: 38 0b ff ff addi r0,r11,-1
**bufp = c;
++(*bufp);
--(*nleft);
}
**bufp = '\0';
++(*bufp);
ffc05740: 91 3e 00 00 stw r9,0(r30)
--(*nleft);
ffc05744: 90 1d 00 00 stw r0,0(r29)
ffc05748: 4b ff ff 80 b ffc056c8 <scanString+0xf8>
ffc0574c <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
ffc0574c: 94 21 ff d0 stwu r1,-48(r1)
ffc05750: 7c 08 02 a6 mflr r0
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
ffc05754: 38 e0 00 00 li r7,0
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
ffc05758: 90 a1 00 18 stw r5,24(r1)
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
ffc0575c: 38 a1 00 18 addi r5,r1,24
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
ffc05760: 90 c1 00 1c stw r6,28(r1)
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
ffc05764: 38 c1 00 1c addi r6,r1,28
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
ffc05768: 93 a1 00 24 stw r29,36(r1)
ffc0576c: 7c 9d 23 78 mr r29,r4
ffc05770: 93 c1 00 28 stw r30,40(r1)
ffc05774: 7c 7e 1b 78 mr r30,r3
ffc05778: 93 e1 00 2c stw r31,44(r1)
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;
ffc0577c: 3b e0 00 00 li r31,0
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
ffc05780: 90 01 00 34 stw r0,52(r1)
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
ffc05784: 4b ff fe 4d bl ffc055d0 <scanString>
ffc05788: 2f 83 00 00 cmpwi cr7,r3,0
ffc0578c: 40 9e 00 24 bne- cr7,ffc057b0 <scangr+0x64>
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
return 1;
}
ffc05790: 80 01 00 34 lwz r0,52(r1)
ffc05794: 7f e3 fb 78 mr r3,r31
ffc05798: 83 a1 00 24 lwz r29,36(r1)
ffc0579c: 7c 08 03 a6 mtlr r0
ffc057a0: 83 c1 00 28 lwz r30,40(r1)
ffc057a4: 83 e1 00 2c lwz r31,44(r1)
ffc057a8: 38 21 00 30 addi r1,r1,48
ffc057ac: 4e 80 00 20 blr
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
ffc057b0: 7f c3 f3 78 mr r3,r30
ffc057b4: 38 9d 00 04 addi r4,r29,4
ffc057b8: 38 a1 00 18 addi r5,r1,24
ffc057bc: 38 c1 00 1c addi r6,r1,28
ffc057c0: 38 e0 00 00 li r7,0
ffc057c4: 4b ff fe 0d bl ffc055d0 <scanString>
ffc057c8: 2f 83 00 00 cmpwi cr7,r3,0
ffc057cc: 41 9e ff c4 beq+ cr7,ffc05790 <scangr+0x44> <== NEVER TAKEN
|| !scanInt(fp, &grgid)
ffc057d0: 7f c3 f3 78 mr r3,r30
ffc057d4: 38 81 00 0c addi r4,r1,12
ffc057d8: 4b ff fc 71 bl ffc05448 <scanInt>
ffc057dc: 2f 83 00 00 cmpwi cr7,r3,0
ffc057e0: 41 9e ff b0 beq+ cr7,ffc05790 <scangr+0x44> <== NEVER TAKEN
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
ffc057e4: 7f c3 f3 78 mr r3,r30
ffc057e8: 38 81 00 08 addi r4,r1,8
ffc057ec: 38 a1 00 18 addi r5,r1,24
ffc057f0: 38 c1 00 1c addi r6,r1,28
ffc057f4: 38 e0 00 01 li r7,1
ffc057f8: 4b ff fd d9 bl ffc055d0 <scanString>
ffc057fc: 2f 83 00 00 cmpwi cr7,r3,0
ffc05800: 41 be ff 90 beq- cr7,ffc05790 <scangr+0x44> <== NEVER TAKEN
return 0;
grp->gr_gid = grgid;
ffc05804: 80 01 00 0c lwz r0,12(r1)
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
ffc05808: 39 20 00 17 li r9,23
ffc0580c: 81 01 00 08 lwz r8,8(r1)
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;
ffc05810: b0 1d 00 08 sth r0,8(r29)
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
ffc05814: 88 08 00 00 lbz r0,0(r8)
ffc05818: 2f 80 00 00 cmpwi cr7,r0,0
ffc0581c: 41 9e 00 30 beq- cr7,ffc0584c <scangr+0x100> <== NEVER TAKEN
ffc05820: 7d 0b 43 78 mr r11,r8
ffc05824: 39 20 00 01 li r9,1
if(*cp == ',')
memcount++;
ffc05828: 68 0a 00 2c xori r10,r0,44
ffc0582c: 21 4a 00 00 subfic r10,r10,0
ffc05830: 7d 49 01 94 addze r10,r9
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
ffc05834: 8c 0b 00 01 lbzu r0,1(r11)
ffc05838: 2f 80 00 00 cmpwi cr7,r0,0
if(*cp == ',')
memcount++;
ffc0583c: 7d 49 53 78 mr r9,r10
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
ffc05840: 40 9e ff e8 bne+ cr7,ffc05828 <scangr+0xdc>
ffc05844: 55 49 10 3a rlwinm r9,r10,2,0,29
ffc05848: 39 29 00 13 addi r9,r9,19
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
ffc0584c: 80 01 00 1c lwz r0,28(r1)
return 0;
ffc05850: 3b e0 00 00 li r31,0
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
ffc05854: 7f 80 48 40 cmplw cr7,r0,r9
ffc05858: 41 bc ff 38 blt- cr7,ffc05790 <scangr+0x44> <== NEVER TAKEN
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
ffc0585c: 81 21 00 18 lwz r9,24(r1)
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
ffc05860: 39 40 00 04 li r10,4
/*
* 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);
ffc05864: 39 29 00 0f addi r9,r9,15
ffc05868: 55 29 00 36 rlwinm r9,r9,0,0,27
ffc0586c: 91 3d 00 0c stw r9,12(r29)
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
ffc05870: 91 09 00 00 stw r8,0(r9)
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
ffc05874: 81 61 00 08 lwz r11,8(r1)
ffc05878: 88 0b 00 00 lbz r0,0(r11)
ffc0587c: 2f 80 00 00 cmpwi cr7,r0,0
ffc05880: 41 9e 00 48 beq- cr7,ffc058c8 <scangr+0x17c> <== NEVER TAKEN
}
/*
* Extract a single group record from the database
*/
static int scangr(
ffc05884: 39 2b 00 01 addi r9,r11,1
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
ffc05888: 39 40 00 01 li r10,1
if(*cp == ',') {
*cp = '\0';
ffc0588c: 38 e0 00 00 li r7,0
ffc05890: 48 00 00 14 b ffc058a4 <scangr+0x158>
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
ffc05894: 8c 0b 00 01 lbzu r0,1(r11)
ffc05898: 39 29 00 01 addi r9,r9,1
ffc0589c: 2f 80 00 00 cmpwi cr7,r0,0
ffc058a0: 41 9e 00 24 beq- cr7,ffc058c4 <scangr+0x178>
if(*cp == ',') {
ffc058a4: 2f 80 00 2c cmpwi cr7,r0,44
ffc058a8: 40 9e ff ec bne+ cr7,ffc05894 <scangr+0x148>
*cp = '\0';
ffc058ac: 98 e9 ff ff stb r7,-1(r9)
grp->gr_mem[memcount++] = cp + 1;
ffc058b0: 55 40 10 3a rlwinm r0,r10,2,0,29
ffc058b4: 39 4a 00 01 addi r10,r10,1
ffc058b8: 81 1d 00 0c lwz r8,12(r29)
ffc058bc: 7d 28 01 2e stwx r9,r8,r0
ffc058c0: 4b ff ff d4 b ffc05894 <scangr+0x148>
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
ffc058c4: 55 4a 10 3a rlwinm r10,r10,2,0,29
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
ffc058c8: 81 3d 00 0c lwz r9,12(r29)
ffc058cc: 38 00 00 00 li r0,0
return 1;
ffc058d0: 3b e0 00 01 li r31,1
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
ffc058d4: 7c 09 51 2e stwx r0,r9,r10
return 1;
ffc058d8: 4b ff fe b8 b ffc05790 <scangr+0x44>
ffc058dc <scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
ffc058dc: 94 21 ff d0 stwu r1,-48(r1)
ffc058e0: 7c 08 02 a6 mflr r0
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
ffc058e4: 38 e0 00 00 li r7,0
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
ffc058e8: 90 a1 00 18 stw r5,24(r1)
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
ffc058ec: 38 a1 00 18 addi r5,r1,24
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
ffc058f0: 90 c1 00 1c stw r6,28(r1)
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
ffc058f4: 38 c1 00 1c addi r6,r1,28
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
ffc058f8: 93 a1 00 24 stw r29,36(r1)
ffc058fc: 7c 9d 23 78 mr r29,r4
ffc05900: 93 c1 00 28 stw r30,40(r1)
ffc05904: 7c 7e 1b 78 mr r30,r3
ffc05908: 93 e1 00 2c stw r31,44(r1)
|| !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;
ffc0590c: 3b e0 00 00 li r31,0
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
ffc05910: 90 01 00 34 stw r0,52(r1)
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
ffc05914: 4b ff fc bd bl ffc055d0 <scanString>
ffc05918: 2f 83 00 00 cmpwi cr7,r3,0
ffc0591c: 40 9e 00 24 bne- cr7,ffc05940 <scanpw+0x64>
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
return 0;
pwd->pw_uid = pwuid;
pwd->pw_gid = pwgid;
return 1;
}
ffc05920: 80 01 00 34 lwz r0,52(r1)
ffc05924: 7f e3 fb 78 mr r3,r31
ffc05928: 83 a1 00 24 lwz r29,36(r1)
ffc0592c: 7c 08 03 a6 mtlr r0
ffc05930: 83 c1 00 28 lwz r30,40(r1)
ffc05934: 83 e1 00 2c lwz r31,44(r1)
ffc05938: 38 21 00 30 addi r1,r1,48
ffc0593c: 4e 80 00 20 blr
)
{
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)
ffc05940: 7f c3 f3 78 mr r3,r30
ffc05944: 38 9d 00 04 addi r4,r29,4
ffc05948: 38 a1 00 18 addi r5,r1,24
ffc0594c: 38 c1 00 1c addi r6,r1,28
ffc05950: 38 e0 00 00 li r7,0
ffc05954: 4b ff fc 7d bl ffc055d0 <scanString>
ffc05958: 2f 83 00 00 cmpwi cr7,r3,0
ffc0595c: 41 9e ff c4 beq+ cr7,ffc05920 <scanpw+0x44> <== NEVER TAKEN
|| !scanInt(fp, &pwuid)
ffc05960: 7f c3 f3 78 mr r3,r30
ffc05964: 38 81 00 0c addi r4,r1,12
ffc05968: 4b ff fa e1 bl ffc05448 <scanInt>
ffc0596c: 2f 83 00 00 cmpwi cr7,r3,0
ffc05970: 41 9e ff b0 beq+ cr7,ffc05920 <scanpw+0x44>
|| !scanInt(fp, &pwgid)
ffc05974: 7f c3 f3 78 mr r3,r30
ffc05978: 38 81 00 08 addi r4,r1,8
ffc0597c: 4b ff fa cd bl ffc05448 <scanInt>
ffc05980: 2f 83 00 00 cmpwi cr7,r3,0
ffc05984: 41 9e ff 9c beq+ cr7,ffc05920 <scanpw+0x44>
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
ffc05988: 7f c3 f3 78 mr r3,r30
ffc0598c: 38 9d 00 0c addi r4,r29,12
ffc05990: 38 a1 00 18 addi r5,r1,24
ffc05994: 38 c1 00 1c addi r6,r1,28
ffc05998: 38 e0 00 00 li r7,0
ffc0599c: 4b ff fc 35 bl ffc055d0 <scanString>
ffc059a0: 2f 83 00 00 cmpwi cr7,r3,0
ffc059a4: 41 9e ff 7c beq+ cr7,ffc05920 <scanpw+0x44> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
ffc059a8: 7f c3 f3 78 mr r3,r30
ffc059ac: 38 9d 00 10 addi r4,r29,16
ffc059b0: 38 a1 00 18 addi r5,r1,24
ffc059b4: 38 c1 00 1c addi r6,r1,28
ffc059b8: 38 e0 00 00 li r7,0
ffc059bc: 4b ff fc 15 bl ffc055d0 <scanString>
ffc059c0: 2f 83 00 00 cmpwi cr7,r3,0
ffc059c4: 41 9e ff 5c beq+ cr7,ffc05920 <scanpw+0x44> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
ffc059c8: 7f c3 f3 78 mr r3,r30
ffc059cc: 38 9d 00 14 addi r4,r29,20
ffc059d0: 38 a1 00 18 addi r5,r1,24
ffc059d4: 38 c1 00 1c addi r6,r1,28
ffc059d8: 38 e0 00 00 li r7,0
ffc059dc: 4b ff fb f5 bl ffc055d0 <scanString>
ffc059e0: 2f 83 00 00 cmpwi cr7,r3,0
ffc059e4: 41 9e ff 3c beq+ cr7,ffc05920 <scanpw+0x44> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
ffc059e8: 7f c3 f3 78 mr r3,r30
ffc059ec: 38 9d 00 18 addi r4,r29,24
ffc059f0: 38 a1 00 18 addi r5,r1,24
ffc059f4: 38 c1 00 1c addi r6,r1,28
ffc059f8: 38 e0 00 01 li r7,1
ffc059fc: 4b ff fb d5 bl ffc055d0 <scanString>
ffc05a00: 2f 83 00 00 cmpwi cr7,r3,0
ffc05a04: 41 be ff 1c beq- cr7,ffc05920 <scanpw+0x44>
return 0;
pwd->pw_uid = pwuid;
ffc05a08: 80 01 00 0c lwz r0,12(r1)
pwd->pw_gid = pwgid;
return 1;
ffc05a0c: 3b e0 00 01 li r31,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;
ffc05a10: b0 1d 00 08 sth r0,8(r29)
pwd->pw_gid = pwgid;
ffc05a14: 80 01 00 08 lwz r0,8(r1)
ffc05a18: b0 1d 00 0a sth r0,10(r29)
return 1;
ffc05a1c: 4b ff ff 04 b ffc05920 <scanpw+0x44>
ffc09910 <sched_get_priority_max>:
int sched_get_priority_max(
int policy
)
{
switch ( policy ) {
ffc09910: 2b 83 00 04 cmplwi cr7,r3,4
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
ffc09914: 94 21 ff f8 stwu r1,-8(r1)
ffc09918: 7c 08 02 a6 mflr r0
ffc0991c: 90 01 00 0c stw r0,12(r1)
switch ( policy ) {
ffc09920: 40 9d 00 24 ble- cr7,ffc09944 <sched_get_priority_max+0x34>
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
ffc09924: 48 00 ad f9 bl ffc1471c <__errno>
ffc09928: 38 00 00 16 li r0,22
ffc0992c: 90 03 00 00 stw r0,0(r3)
ffc09930: 38 60 ff ff li r3,-1
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
}
ffc09934: 80 01 00 0c lwz r0,12(r1)
ffc09938: 38 21 00 08 addi r1,r1,8
ffc0993c: 7c 08 03 a6 mtlr r0
ffc09940: 4e 80 00 20 blr
int sched_get_priority_max(
int policy
)
{
switch ( policy ) {
ffc09944: 38 00 00 01 li r0,1
ffc09948: 7c 03 18 30 slw r3,r0,r3
ffc0994c: 70 60 00 17 andi. r0,r3,23
ffc09950: 41 a2 ff d4 beq- ffc09924 <sched_get_priority_max+0x14> <== NEVER TAKEN
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
}
ffc09954: 80 01 00 0c lwz r0,12(r1)
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
ffc09958: 3d 20 00 00 lis r9,0
ffc0995c: 88 69 27 24 lbz r3,10020(r9)
}
ffc09960: 38 21 00 08 addi r1,r1,8
ffc09964: 7c 08 03 a6 mtlr r0
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
ffc09968: 38 63 ff ff addi r3,r3,-1
}
ffc0996c: 4e 80 00 20 blr
ffc09970 <sched_get_priority_min>:
int sched_get_priority_min(
int policy
)
{
switch ( policy ) {
ffc09970: 2b 83 00 04 cmplwi cr7,r3,4
#include <rtems/posix/priority.h>
int sched_get_priority_min(
int policy
)
{
ffc09974: 94 21 ff f8 stwu r1,-8(r1)
ffc09978: 7c 08 02 a6 mflr r0
ffc0997c: 90 01 00 0c stw r0,12(r1)
switch ( policy ) {
ffc09980: 40 9d 00 24 ble- cr7,ffc099a4 <sched_get_priority_min+0x34>
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
ffc09984: 48 00 ad 99 bl ffc1471c <__errno>
ffc09988: 38 00 00 16 li r0,22
ffc0998c: 90 03 00 00 stw r0,0(r3)
ffc09990: 38 60 ff ff li r3,-1
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
}
ffc09994: 80 01 00 0c lwz r0,12(r1)
ffc09998: 38 21 00 08 addi r1,r1,8
ffc0999c: 7c 08 03 a6 mtlr r0
ffc099a0: 4e 80 00 20 blr
int sched_get_priority_min(
int policy
)
{
switch ( policy ) {
ffc099a4: 38 00 00 01 li r0,1
ffc099a8: 7c 03 18 30 slw r3,r0,r3
ffc099ac: 70 60 00 17 andi. r0,r3,23
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
ffc099b0: 38 60 00 01 li r3,1
int sched_get_priority_min(
int policy
)
{
switch ( policy ) {
ffc099b4: 41 a2 ff d0 beq- ffc09984 <sched_get_priority_min+0x14> <== NEVER TAKEN
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
}
ffc099b8: 80 01 00 0c lwz r0,12(r1)
ffc099bc: 38 21 00 08 addi r1,r1,8
ffc099c0: 7c 08 03 a6 mtlr r0
ffc099c4: 4e 80 00 20 blr
ffc099c8 <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
ffc099c8: 94 21 ff e8 stwu r1,-24(r1)
ffc099cc: 7c 08 02 a6 mflr r0
ffc099d0: 93 e1 00 14 stw r31,20(r1)
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
ffc099d4: 7c 7f 1b 79 mr. r31,r3
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
ffc099d8: 90 01 00 1c stw r0,28(r1)
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
ffc099dc: 40 82 00 30 bne- ffc09a0c <sched_rr_get_interval+0x44> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ESRCH );
if ( !interval )
ffc099e0: 2f 84 00 00 cmpwi cr7,r4,0
ffc099e4: 41 9e 00 50 beq- cr7,ffc09a34 <sched_rr_get_interval+0x6c>
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
ffc099e8: 3d 20 00 00 lis r9,0
ffc099ec: 80 69 28 0c lwz r3,10252(r9)
ffc099f0: 48 00 48 d5 bl ffc0e2c4 <_Timespec_From_ticks>
return 0;
ffc099f4: 38 60 00 00 li r3,0
}
ffc099f8: 80 01 00 1c lwz r0,28(r1)
ffc099fc: 83 e1 00 14 lwz r31,20(r1)
ffc09a00: 38 21 00 18 addi r1,r1,24
ffc09a04: 7c 08 03 a6 mtlr r0
ffc09a08: 4e 80 00 20 blr
{
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
ffc09a0c: 90 81 00 08 stw r4,8(r1)
ffc09a10: 4b ff bb 69 bl ffc05578 <getpid>
ffc09a14: 7f 83 f8 00 cmpw cr7,r3,r31
ffc09a18: 80 81 00 08 lwz r4,8(r1)
ffc09a1c: 41 9e ff c4 beq+ cr7,ffc099e0 <sched_rr_get_interval+0x18>
rtems_set_errno_and_return_minus_one( ESRCH );
ffc09a20: 48 00 ac fd bl ffc1471c <__errno>
ffc09a24: 38 00 00 03 li r0,3
ffc09a28: 90 03 00 00 stw r0,0(r3)
ffc09a2c: 38 60 ff ff li r3,-1
ffc09a30: 4b ff ff c8 b ffc099f8 <sched_rr_get_interval+0x30>
if ( !interval )
rtems_set_errno_and_return_minus_one( EINVAL );
ffc09a34: 48 00 ac e9 bl ffc1471c <__errno>
ffc09a38: 38 00 00 16 li r0,22
ffc09a3c: 90 03 00 00 stw r0,0(r3)
ffc09a40: 38 60 ff ff li r3,-1
ffc09a44: 4b ff ff b4 b ffc099f8 <sched_rr_get_interval+0x30>
ffc0c50c <sem_open>:
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc0c50c: 3d 20 00 00 lis r9,0
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
ffc0c510: 94 21 ff b8 stwu r1,-72(r1)
ffc0c514: 7c 08 02 a6 mflr r0
ffc0c518: 81 69 28 08 lwz r11,10248(r9)
ffc0c51c: 7d 80 00 26 mfcr r12
ffc0c520: 90 01 00 4c stw r0,76(r1)
ffc0c524: 39 6b 00 01 addi r11,r11,1
ffc0c528: 91 69 28 08 stw r11,10248(r9)
ffc0c52c: 93 c1 00 40 stw r30,64(r1)
ffc0c530: 7c 7e 1b 78 mr r30,r3
ffc0c534: 93 e1 00 44 stw r31,68(r1)
ffc0c538: 7c 9f 23 78 mr r31,r4
ffc0c53c: 93 81 00 38 stw r28,56(r1)
ffc0c540: 93 a1 00 3c stw r29,60(r1)
ffc0c544: 91 81 00 34 stw r12,52(r1)
ffc0c548: 90 a1 00 28 stw r5,40(r1)
ffc0c54c: 90 c1 00 2c stw r6,44(r1)
return _Thread_Dispatch_disable_level;
ffc0c550: 80 09 28 08 lwz r0,10248(r9)
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
ffc0c554: 54 80 bf fe rlwinm r0,r4,23,31,31
ffc0c558: 2e 00 00 00 cmpwi cr4,r0,0
/* unsigned int value */
)
{
va_list arg;
mode_t mode;
unsigned int value = 0;
ffc0c55c: 3b a0 00 00 li r29,0
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
ffc0c560: 40 92 00 c4 bne- cr4,ffc0c624 <sem_open+0x118>
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
va_end(arg);
}
status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id );
ffc0c564: 7f c3 f3 78 mr r3,r30
ffc0c568: 38 81 00 10 addi r4,r1,16
ffc0c56c: 48 00 83 75 bl ffc148e0 <_POSIX_Semaphore_Name_to_id>
* 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 ) {
ffc0c570: 7c 7c 1b 79 mr. r28,r3
ffc0c574: 41 82 00 48 beq- ffc0c5bc <sem_open+0xb0>
/*
* 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) ) ) {
ffc0c578: 2f 9c 00 02 cmpwi cr7,r28,2
ffc0c57c: 40 9e 00 08 bne- cr7,ffc0c584 <sem_open+0x78> <== NEVER TAKEN
ffc0c580: 40 92 00 c4 bne- cr4,ffc0c644 <sem_open+0x138>
_Thread_Enable_dispatch();
ffc0c584: 48 00 3c 85 bl ffc10208 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
ffc0c588: 48 00 c0 05 bl ffc1858c <__errno>
id = &the_semaphore->Semaphore_id;
#else
id = (sem_t *)&the_semaphore->Object.id;
#endif
return id;
}
ffc0c58c: 80 01 00 4c lwz r0,76(r1)
ffc0c590: 81 81 00 34 lwz r12,52(r1)
ffc0c594: 7c 08 03 a6 mtlr r0
* and we are willing to create then it is an error.
*/
if ( !( status == ENOENT && (oflag & O_CREAT) ) ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
ffc0c598: 93 83 00 00 stw r28,0(r3)
id = &the_semaphore->Semaphore_id;
#else
id = (sem_t *)&the_semaphore->Object.id;
#endif
return id;
}
ffc0c59c: 7d 80 81 20 mtcrf 8,r12
* and we are willing to create then it is an error.
*/
if ( !( status == ENOENT && (oflag & O_CREAT) ) ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
ffc0c5a0: 38 60 ff ff li r3,-1
id = &the_semaphore->Semaphore_id;
#else
id = (sem_t *)&the_semaphore->Object.id;
#endif
return id;
}
ffc0c5a4: 83 81 00 38 lwz r28,56(r1)
ffc0c5a8: 83 a1 00 3c lwz r29,60(r1)
ffc0c5ac: 83 c1 00 40 lwz r30,64(r1)
ffc0c5b0: 83 e1 00 44 lwz r31,68(r1)
ffc0c5b4: 38 21 00 48 addi r1,r1,72
ffc0c5b8: 4e 80 00 20 blr
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
ffc0c5bc: 73 ff 0a 00 andi. r31,r31,2560
ffc0c5c0: 2f 9f 0a 00 cmpwi cr7,r31,2560
ffc0c5c4: 41 9e 00 ac beq- cr7,ffc0c670 <sem_open+0x164>
ffc0c5c8: 80 81 00 10 lwz r4,16(r1)
ffc0c5cc: 3c 60 00 00 lis r3,0
ffc0c5d0: 38 a1 00 08 addi r5,r1,8
ffc0c5d4: 38 63 30 ac addi r3,r3,12460
ffc0c5d8: 48 00 2a 91 bl ffc0f068 <_Objects_Get>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
}
the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location );
the_semaphore->open_count += 1;
ffc0c5dc: 81 23 00 18 lwz r9,24(r3)
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 );
ffc0c5e0: 90 61 00 0c stw r3,12(r1)
the_semaphore->open_count += 1;
ffc0c5e4: 38 09 00 01 addi r0,r9,1
ffc0c5e8: 90 03 00 18 stw r0,24(r3)
_Thread_Enable_dispatch();
ffc0c5ec: 48 00 3c 1d bl ffc10208 <_Thread_Enable_dispatch>
_Thread_Enable_dispatch();
ffc0c5f0: 48 00 3c 19 bl ffc10208 <_Thread_Enable_dispatch>
the_semaphore->Semaphore_id = the_semaphore->Object.id;
id = &the_semaphore->Semaphore_id;
#else
id = (sem_t *)&the_semaphore->Object.id;
#endif
return id;
ffc0c5f4: 80 61 00 0c lwz r3,12(r1)
ffc0c5f8: 38 63 00 08 addi r3,r3,8
}
ffc0c5fc: 80 01 00 4c lwz r0,76(r1)
ffc0c600: 81 81 00 34 lwz r12,52(r1)
ffc0c604: 7c 08 03 a6 mtlr r0
ffc0c608: 83 81 00 38 lwz r28,56(r1)
ffc0c60c: 83 a1 00 3c lwz r29,60(r1)
ffc0c610: 7d 80 81 20 mtcrf 8,r12
ffc0c614: 83 c1 00 40 lwz r30,64(r1)
ffc0c618: 83 e1 00 44 lwz r31,68(r1)
ffc0c61c: 38 21 00 48 addi r1,r1,72
ffc0c620: 4e 80 00 20 blr
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
ffc0c624: 38 01 00 50 addi r0,r1,80
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
ffc0c628: 83 a1 00 2c lwz r29,44(r1)
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
ffc0c62c: 90 01 00 18 stw r0,24(r1)
ffc0c630: 38 01 00 20 addi r0,r1,32
ffc0c634: 90 01 00 1c stw r0,28(r1)
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
ffc0c638: 38 00 00 04 li r0,4
ffc0c63c: 98 01 00 14 stb r0,20(r1)
ffc0c640: 4b ff ff 24 b ffc0c564 <sem_open+0x58>
/*
* 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(
ffc0c644: 38 80 00 00 li r4,0
ffc0c648: 7f a5 eb 78 mr r5,r29
ffc0c64c: 38 c1 00 0c addi r6,r1,12
ffc0c650: 7f c3 f3 78 mr r3,r30
ffc0c654: 48 00 80 a1 bl ffc146f4 <_POSIX_Semaphore_Create_support>
ffc0c658: 7c 7f 1b 78 mr r31,r3
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
ffc0c65c: 48 00 3b ad bl ffc10208 <_Thread_Enable_dispatch>
if ( status == -1 )
ffc0c660: 2f 9f ff ff cmpwi cr7,r31,-1
return SEM_FAILED;
ffc0c664: 38 60 ff ff li r3,-1
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
if ( status == -1 )
ffc0c668: 40 9e ff 8c bne+ cr7,ffc0c5f4 <sem_open+0xe8>
ffc0c66c: 4b ff ff 90 b ffc0c5fc <sem_open+0xf0>
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
_Thread_Enable_dispatch();
ffc0c670: 48 00 3b 99 bl ffc10208 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
ffc0c674: 48 00 bf 19 bl ffc1858c <__errno>
ffc0c678: 38 00 00 11 li r0,17
ffc0c67c: 90 03 00 00 stw r0,0(r3)
ffc0c680: 38 60 ff ff li r3,-1
ffc0c684: 4b ff ff 78 b ffc0c5fc <sem_open+0xf0>
ffc0c6fc <sem_timedwait>:
int sem_timedwait(
sem_t *sem,
const struct timespec *abstime
)
{
ffc0c6fc: 94 21 ff e0 stwu r1,-32(r1)
ffc0c700: 7c 08 02 a6 mflr r0
ffc0c704: 93 e1 00 1c stw r31,28(r1)
ffc0c708: 7c 7f 1b 78 mr r31,r3
*
* 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 );
ffc0c70c: 7c 83 23 78 mr r3,r4
ffc0c710: 38 81 00 08 addi r4,r1,8
int sem_timedwait(
sem_t *sem,
const struct timespec *abstime
)
{
ffc0c714: 90 01 00 24 stw r0,36(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 );
ffc0c718: 48 00 74 0d bl ffc13b24 <_POSIX_Absolute_timeout_to_ticks>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
ffc0c71c: 2f 83 00 03 cmpwi cr7,r3,3
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
ffc0c720: 80 a1 00 08 lwz r5,8(r1)
ffc0c724: 7f e3 fb 78 mr r3,r31
* 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 );
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
ffc0c728: 41 9e 00 20 beq- cr7,ffc0c748 <sem_timedwait+0x4c> <== ALWAYS TAKEN
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
ffc0c72c: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc0c730: 48 00 82 65 bl ffc14994 <_POSIX_Semaphore_Wait_support><== NOT EXECUTED
lock_status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
rtems_set_errno_and_return_minus_one( ETIMEDOUT );
}
return lock_status;
}
ffc0c734: 80 01 00 24 lwz r0,36(r1) <== NOT EXECUTED
ffc0c738: 83 e1 00 1c lwz r31,28(r1) <== NOT EXECUTED
ffc0c73c: 38 21 00 20 addi r1,r1,32 <== NOT EXECUTED
ffc0c740: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc0c744: 4e 80 00 20 blr <== NOT EXECUTED
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
ffc0c748: 38 80 00 01 li r4,1
ffc0c74c: 48 00 82 49 bl ffc14994 <_POSIX_Semaphore_Wait_support>
lock_status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
rtems_set_errno_and_return_minus_one( ETIMEDOUT );
}
return lock_status;
}
ffc0c750: 80 01 00 24 lwz r0,36(r1)
ffc0c754: 83 e1 00 1c lwz r31,28(r1)
ffc0c758: 38 21 00 20 addi r1,r1,32
ffc0c75c: 7c 08 03 a6 mtlr r0
ffc0c760: 4e 80 00 20 blr
ffc097c8 <sigaction>:
struct sigaction *oact
)
{
ISR_Level level;
if ( oact )
ffc097c8: 2c 05 00 00 cmpwi r5,0
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
ffc097cc: 94 21 ff e8 stwu r1,-24(r1)
ffc097d0: 7c 08 02 a6 mflr r0
ffc097d4: 93 c1 00 10 stw r30,16(r1)
ffc097d8: 7c 9e 23 78 mr r30,r4
ffc097dc: 93 e1 00 14 stw r31,20(r1)
ffc097e0: 7c 7f 1b 78 mr r31,r3
ffc097e4: 90 01 00 1c stw r0,28(r1)
ffc097e8: 93 a1 00 0c stw r29,12(r1)
ISR_Level level;
if ( oact )
ffc097ec: 41 82 00 2c beq- ffc09818 <sigaction+0x50>
*oact = _POSIX_signals_Vectors[ sig ];
ffc097f0: 1c 03 00 0c mulli r0,r3,12
ffc097f4: 3d 60 00 00 lis r11,0
ffc097f8: 39 6b 32 00 addi r11,r11,12800
ffc097fc: 7d 2b 02 14 add r9,r11,r0
ffc09800: 7d 4b 00 2e lwzx r10,r11,r0
ffc09804: 81 69 00 04 lwz r11,4(r9)
ffc09808: 80 09 00 08 lwz r0,8(r9)
ffc0980c: 91 45 00 00 stw r10,0(r5)
ffc09810: 91 65 00 04 stw r11,4(r5)
ffc09814: 90 05 00 08 stw r0,8(r5)
if ( !sig )
ffc09818: 2f 9f 00 00 cmpwi cr7,r31,0
ffc0981c: 41 9e 00 cc beq- cr7,ffc098e8 <sigaction+0x120>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
ffc09820: 38 1f ff ff addi r0,r31,-1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
ffc09824: 2b 80 00 1f cmplwi cr7,r0,31
ffc09828: 41 9d 00 c0 bgt- cr7,ffc098e8 <sigaction+0x120>
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
ffc0982c: 2f 9f 00 09 cmpwi cr7,r31,9
ffc09830: 41 9e 00 b8 beq- cr7,ffc098e8 <sigaction+0x120>
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
ffc09834: 2f 9e 00 00 cmpwi cr7,r30,0
* 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;
ffc09838: 38 60 00 00 li r3,0
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
ffc0983c: 41 9e 00 58 beq- cr7,ffc09894 <sigaction+0xcc> <== NEVER TAKEN
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc09840: 7f a0 00 a6 mfmsr r29
ffc09844: 7c 10 42 a6 mfsprg r0,0
ffc09848: 7f a0 00 78 andc r0,r29,r0
ffc0984c: 7c 00 01 24 mtmsr r0
* Unless the user is installing the default signal actions, then
* we can just copy the provided sigaction structure into the vectors.
*/
_ISR_Disable( level );
if ( act->sa_handler == SIG_DFL ) {
ffc09850: 80 1e 00 08 lwz r0,8(r30)
ffc09854: 2f 80 00 00 cmpwi cr7,r0,0
ffc09858: 41 9e 00 58 beq- cr7,ffc098b0 <sigaction+0xe8>
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
} else {
_POSIX_signals_Clear_process_signals( sig );
ffc0985c: 7f e3 fb 78 mr r3,r31
ffc09860: 48 00 78 41 bl ffc110a0 <_POSIX_signals_Clear_process_signals>
_POSIX_signals_Vectors[ sig ] = *act;
ffc09864: 1f ff 00 0c mulli r31,r31,12
ffc09868: 81 1e 00 00 lwz r8,0(r30)
ffc0986c: 3d 60 00 00 lis r11,0
ffc09870: 81 5e 00 04 lwz r10,4(r30)
ffc09874: 80 1e 00 08 lwz r0,8(r30)
ffc09878: 39 6b 32 00 addi r11,r11,12800
ffc0987c: 7d 2b fa 14 add r9,r11,r31
ffc09880: 7d 0b f9 2e stwx r8,r11,r31
ffc09884: 91 49 00 04 stw r10,4(r9)
ffc09888: 90 09 00 08 stw r0,8(r9)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0988c: 7f a0 01 24 mtmsr r29
* 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;
ffc09890: 38 60 00 00 li r3,0
}
ffc09894: 80 01 00 1c lwz r0,28(r1)
ffc09898: 83 a1 00 0c lwz r29,12(r1)
ffc0989c: 7c 08 03 a6 mtlr r0
ffc098a0: 83 c1 00 10 lwz r30,16(r1)
ffc098a4: 83 e1 00 14 lwz r31,20(r1)
ffc098a8: 38 21 00 18 addi r1,r1,24
ffc098ac: 4e 80 00 20 blr
* we can just copy the provided sigaction structure into the vectors.
*/
_ISR_Disable( level );
if ( act->sa_handler == SIG_DFL ) {
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
ffc098b0: 1f ff 00 0c mulli r31,r31,12
ffc098b4: 3d 40 ff c2 lis r10,-62
ffc098b8: 39 4a e8 00 addi r10,r10,-6144
ffc098bc: 7d 2a fa 14 add r9,r10,r31
ffc098c0: 7d 0a f8 2e lwzx r8,r10,r31
ffc098c4: 3d 60 00 00 lis r11,0
ffc098c8: 81 49 00 04 lwz r10,4(r9)
ffc098cc: 39 6b 32 00 addi r11,r11,12800
ffc098d0: 80 09 00 08 lwz r0,8(r9)
ffc098d4: 7d 2b fa 14 add r9,r11,r31
ffc098d8: 7d 0b f9 2e stwx r8,r11,r31
ffc098dc: 91 49 00 04 stw r10,4(r9)
ffc098e0: 90 09 00 08 stw r0,8(r9)
ffc098e4: 4b ff ff a8 b ffc0988c <sigaction+0xc4>
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
rtems_set_errno_and_return_minus_one( EINVAL );
ffc098e8: 48 00 b3 c9 bl ffc14cb0 <__errno>
ffc098ec: 38 00 00 16 li r0,22
ffc098f0: 90 03 00 00 stw r0,0(r3)
ffc098f4: 38 60 ff ff li r3,-1
ffc098f8: 4b ff ff 9c b ffc09894 <sigaction+0xcc>
ffc09dec <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
ffc09dec: 94 21 ff d0 stwu r1,-48(r1)
ffc09df0: 7c 08 02 a6 mflr r0
ffc09df4: 93 a1 00 24 stw r29,36(r1)
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
ffc09df8: 7c 7d 1b 79 mr. r29,r3
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
ffc09dfc: 93 c1 00 28 stw r30,40(r1)
ffc09e00: 7c be 2b 78 mr r30,r5
ffc09e04: 93 e1 00 2c stw r31,44(r1)
ffc09e08: 7c 9f 23 78 mr r31,r4
ffc09e0c: 90 01 00 34 stw r0,52(r1)
ffc09e10: 93 41 00 18 stw r26,24(r1)
ffc09e14: 93 61 00 1c stw r27,28(r1)
ffc09e18: 93 81 00 20 stw r28,32(r1)
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
ffc09e1c: 41 82 02 4c beq- ffc0a068 <sigtimedwait+0x27c>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
if ( timeout ) {
ffc09e20: 2f 85 00 00 cmpwi cr7,r5,0
ffc09e24: 41 9e 01 a0 beq- cr7,ffc09fc4 <sigtimedwait+0x1d8>
if ( !_Timespec_Is_valid( timeout ) )
ffc09e28: 7c a3 2b 78 mr r3,r5
ffc09e2c: 48 00 49 99 bl ffc0e7c4 <_Timespec_Is_valid>
ffc09e30: 2f 83 00 00 cmpwi cr7,r3,0
ffc09e34: 41 9e 02 34 beq- cr7,ffc0a068 <sigtimedwait+0x27c>
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
ffc09e38: 7f c3 f3 78 mr r3,r30
ffc09e3c: 48 00 4a 11 bl ffc0e84c <_Timespec_To_ticks>
if ( !interval )
ffc09e40: 7c 64 1b 79 mr. r4,r3
ffc09e44: 41 82 02 24 beq- ffc0a068 <sigtimedwait+0x27c> <== NEVER TAKEN
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
ffc09e48: 2f 9f 00 00 cmpwi cr7,r31,0
ffc09e4c: 41 9e 01 84 beq- cr7,ffc09fd0 <sigtimedwait+0x1e4> <== NEVER TAKEN
the_thread = _Thread_Executing;
ffc09e50: 3f 80 00 00 lis r28,0
ffc09e54: 3b 9c 31 84 addi r28,r28,12676
ffc09e58: 81 3c 00 0c lwz r9,12(r28)
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
ffc09e5c: 83 49 01 34 lwz r26,308(r9)
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc09e60: 7f 60 00 a6 mfmsr r27
ffc09e64: 7c 10 42 a6 mfsprg r0,0
ffc09e68: 7f 60 00 78 andc r0,r27,r0
ffc09e6c: 7c 00 01 24 mtmsr r0
*/
/* API signals pending? */
_ISR_Disable( level );
if ( *set & api->signals_pending ) {
ffc09e70: 80 1d 00 00 lwz r0,0(r29)
ffc09e74: 80 7a 00 d4 lwz r3,212(r26)
ffc09e78: 7c 0b 18 39 and. r11,r0,r3
ffc09e7c: 40 82 01 88 bne- ffc0a004 <sigtimedwait+0x218>
return the_info->si_signo;
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
ffc09e80: 3d 60 00 00 lis r11,0
ffc09e84: 80 6b 28 bc lwz r3,10428(r11)
ffc09e88: 7c 0b 18 39 and. r11,r0,r3
ffc09e8c: 40 82 00 d4 bne- ffc09f60 <sigtimedwait+0x174>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc09e90: 3d 60 00 00 lis r11,0
ffc09e94: 81 4b 28 78 lwz r10,10360(r11)
ffc09e98: 38 0a 00 01 addi r0,r10,1
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
return signo;
}
the_info->si_signo = -1;
ffc09e9c: 39 40 ff ff li r10,-1
ffc09ea0: 91 5f 00 00 stw r10,0(r31)
ffc09ea4: 90 0b 28 78 stw r0,10360(r11)
return _Thread_Dispatch_disable_level;
ffc09ea8: 80 0b 28 78 lwz r0,10360(r11)
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
the_thread->Wait.return_code = EINTR;
ffc09eac: 38 00 00 04 li r0,4
ffc09eb0: 90 09 00 34 stw r0,52(r9)
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
ffc09eb4: 3d 60 00 00 lis r11,0
ffc09eb8: 39 6b 33 8c addi r11,r11,13196
the_thread->Wait.return_code = EINTR;
the_thread->Wait.option = *set;
ffc09ebc: 80 1d 00 00 lwz r0,0(r29)
the_thread->Wait.return_argument = the_info;
ffc09ec0: 93 e9 00 28 stw r31,40(r9)
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
the_thread->Wait.return_code = EINTR;
the_thread->Wait.option = *set;
ffc09ec4: 90 09 00 30 stw r0,48(r9)
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;
ffc09ec8: 38 00 00 01 li r0,1
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
ffc09ecc: 91 69 00 44 stw r11,68(r9)
ffc09ed0: 90 0b 00 30 stw r0,48(r11)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc09ed4: 7f 60 01 24 mtmsr r27
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 );
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
ffc09ed8: 3c a0 ff c1 lis r5,-63
ffc09edc: 3c 60 00 00 lis r3,0
ffc09ee0: 38 a5 e4 48 addi r5,r5,-7096
ffc09ee4: 38 63 33 8c addi r3,r3,13196
ffc09ee8: 48 00 40 f1 bl ffc0dfd8 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
ffc09eec: 48 00 3a d5 bl ffc0d9c0 <_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 );
ffc09ef0: 80 9f 00 00 lwz r4,0(r31)
ffc09ef4: 7f 43 d3 78 mr r3,r26
ffc09ef8: 7f e5 fb 78 mr r5,r31
ffc09efc: 38 c0 00 00 li r6,0
ffc09f00: 38 e0 00 00 li r7,0
ffc09f04: 48 00 7b 45 bl ffc11a48 <_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)
ffc09f08: 81 3c 00 0c lwz r9,12(r28)
ffc09f0c: 80 09 00 34 lwz r0,52(r9)
ffc09f10: 2f 80 00 04 cmpwi cr7,r0,4
ffc09f14: 40 9e 01 68 bne- cr7,ffc0a07c <sigtimedwait+0x290>
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
ffc09f18: 83 df 00 00 lwz r30,0(r31)
ffc09f1c: 39 60 00 01 li r11,1
ffc09f20: 80 1d 00 00 lwz r0,0(r29)
ffc09f24: 39 3e ff ff addi r9,r30,-1
ffc09f28: 7d 69 48 30 slw r9,r11,r9
ffc09f2c: 7d 2b 00 39 and. r11,r9,r0
ffc09f30: 41 82 01 4c beq- ffc0a07c <sigtimedwait+0x290>
errno = _Thread_Executing->Wait.return_code;
return -1;
}
return the_info->si_signo;
}
ffc09f34: 80 01 00 34 lwz r0,52(r1)
ffc09f38: 7f c3 f3 78 mr r3,r30
ffc09f3c: 83 41 00 18 lwz r26,24(r1)
ffc09f40: 7c 08 03 a6 mtlr r0
ffc09f44: 83 61 00 1c lwz r27,28(r1)
ffc09f48: 83 81 00 20 lwz r28,32(r1)
ffc09f4c: 83 a1 00 24 lwz r29,36(r1)
ffc09f50: 83 c1 00 28 lwz r30,40(r1)
ffc09f54: 83 e1 00 2c lwz r31,44(r1)
ffc09f58: 38 21 00 30 addi r1,r1,48
ffc09f5c: 4e 80 00 20 blr
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
ffc09f60: 4b ff fe 31 bl ffc09d90 <_POSIX_signals_Get_lowest>
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
ffc09f64: 7f e5 fb 78 mr r5,r31
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
ffc09f68: 7c 7e 1b 78 mr r30,r3
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
ffc09f6c: 7f c4 f3 78 mr r4,r30
ffc09f70: 7f 43 d3 78 mr r3,r26
ffc09f74: 38 c0 00 01 li r6,1
ffc09f78: 38 e0 00 00 li r7,0
ffc09f7c: 48 00 7a cd bl ffc11a48 <_POSIX_signals_Clear_signals>
ffc09f80: 7f 60 01 24 mtmsr r27
_ISR_Enable( level );
the_info->si_signo = signo;
the_info->si_code = SI_USER;
ffc09f84: 38 00 00 01 li r0,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;
ffc09f88: 93 df 00 00 stw r30,0(r31)
errno = _Thread_Executing->Wait.return_code;
return -1;
}
return the_info->si_signo;
}
ffc09f8c: 7f c3 f3 78 mr r3,r30
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;
the_info->si_code = SI_USER;
ffc09f90: 90 1f 00 04 stw r0,4(r31)
the_info->si_value.sival_int = 0;
ffc09f94: 38 00 00 00 li r0,0
ffc09f98: 90 1f 00 08 stw r0,8(r31)
errno = _Thread_Executing->Wait.return_code;
return -1;
}
return the_info->si_signo;
}
ffc09f9c: 80 01 00 34 lwz r0,52(r1)
ffc09fa0: 83 41 00 18 lwz r26,24(r1)
ffc09fa4: 7c 08 03 a6 mtlr r0
ffc09fa8: 83 61 00 1c lwz r27,28(r1)
ffc09fac: 83 81 00 20 lwz r28,32(r1)
ffc09fb0: 83 a1 00 24 lwz r29,36(r1)
ffc09fb4: 83 c1 00 28 lwz r30,40(r1)
ffc09fb8: 83 e1 00 2c lwz r31,44(r1)
ffc09fbc: 38 21 00 30 addi r1,r1,48
ffc09fc0: 4e 80 00 20 blr
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
ffc09fc4: 2f 9f 00 00 cmpwi cr7,r31,0
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
ffc09fc8: 38 80 00 00 li r4,0
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
ffc09fcc: 40 9e fe 84 bne+ cr7,ffc09e50 <sigtimedwait+0x64>
the_thread = _Thread_Executing;
ffc09fd0: 3f 80 00 00 lis r28,0
ffc09fd4: 3b 9c 31 84 addi r28,r28,12676
ffc09fd8: 81 3c 00 0c lwz r9,12(r28)
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
ffc09fdc: 3b e1 00 08 addi r31,r1,8
the_thread = _Thread_Executing;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
ffc09fe0: 83 49 01 34 lwz r26,308(r9)
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc09fe4: 7f 60 00 a6 mfmsr r27
ffc09fe8: 7c 10 42 a6 mfsprg r0,0
ffc09fec: 7f 60 00 78 andc r0,r27,r0
ffc09ff0: 7c 00 01 24 mtmsr r0
*/
/* API signals pending? */
_ISR_Disable( level );
if ( *set & api->signals_pending ) {
ffc09ff4: 80 1d 00 00 lwz r0,0(r29)
ffc09ff8: 80 7a 00 d4 lwz r3,212(r26)
ffc09ffc: 7c 0b 18 39 and. r11,r0,r3
ffc0a000: 41 82 fe 80 beq+ ffc09e80 <sigtimedwait+0x94>
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
ffc0a004: 4b ff fd 8d bl ffc09d90 <_POSIX_signals_Get_lowest>
_POSIX_signals_Clear_signals(
ffc0a008: 7f e5 fb 78 mr r5,r31
/* API signals pending? */
_ISR_Disable( level );
if ( *set & api->signals_pending ) {
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
ffc0a00c: 90 7f 00 00 stw r3,0(r31)
ffc0a010: 7c 64 1b 78 mr r4,r3
_POSIX_signals_Clear_signals(
ffc0a014: 38 c0 00 00 li r6,0
ffc0a018: 7f 43 d3 78 mr r3,r26
ffc0a01c: 38 e0 00 00 li r7,0
ffc0a020: 48 00 7a 29 bl ffc11a48 <_POSIX_signals_Clear_signals>
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0a024: 7f 60 01 24 mtmsr r27
false,
false
);
_ISR_Enable( level );
the_info->si_code = SI_USER;
ffc0a028: 38 00 00 01 li r0,1
the_info->si_value.sival_int = 0;
return the_info->si_signo;
ffc0a02c: 83 df 00 00 lwz r30,0(r31)
false,
false
);
_ISR_Enable( level );
the_info->si_code = SI_USER;
ffc0a030: 90 1f 00 04 stw r0,4(r31)
the_info->si_value.sival_int = 0;
ffc0a034: 38 00 00 00 li r0,0
errno = _Thread_Executing->Wait.return_code;
return -1;
}
return the_info->si_signo;
}
ffc0a038: 7f c3 f3 78 mr r3,r30
false
);
_ISR_Enable( level );
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
ffc0a03c: 90 1f 00 08 stw r0,8(r31)
errno = _Thread_Executing->Wait.return_code;
return -1;
}
return the_info->si_signo;
}
ffc0a040: 80 01 00 34 lwz r0,52(r1)
ffc0a044: 83 41 00 18 lwz r26,24(r1)
ffc0a048: 7c 08 03 a6 mtlr r0
ffc0a04c: 83 61 00 1c lwz r27,28(r1)
ffc0a050: 83 81 00 20 lwz r28,32(r1)
ffc0a054: 83 a1 00 24 lwz r29,36(r1)
ffc0a058: 83 c1 00 28 lwz r30,40(r1)
ffc0a05c: 83 e1 00 2c lwz r31,44(r1)
ffc0a060: 38 21 00 30 addi r1,r1,48
ffc0a064: 4e 80 00 20 blr
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
if ( !interval )
rtems_set_errno_and_return_minus_one( EINVAL );
ffc0a068: 48 00 b4 79 bl ffc154e0 <__errno>
ffc0a06c: 38 00 00 16 li r0,22
ffc0a070: 90 03 00 00 stw r0,0(r3)
ffc0a074: 3b c0 ff ff li r30,-1
ffc0a078: 4b ff fe bc b ffc09f34 <sigtimedwait+0x148>
* was not in our set.
*/
if ( (_Thread_Executing->Wait.return_code != EINTR)
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
errno = _Thread_Executing->Wait.return_code;
ffc0a07c: 48 00 b4 65 bl ffc154e0 <__errno>
ffc0a080: 81 3c 00 0c lwz r9,12(r28)
return -1;
ffc0a084: 3b c0 ff ff li r30,-1
* was not in our set.
*/
if ( (_Thread_Executing->Wait.return_code != EINTR)
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
errno = _Thread_Executing->Wait.return_code;
ffc0a088: 80 09 00 34 lwz r0,52(r9)
ffc0a08c: 90 03 00 00 stw r0,0(r3)
return -1;
ffc0a090: 4b ff fe a4 b ffc09f34 <sigtimedwait+0x148>
ffc0c0f4 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
ffc0c0f4: 94 21 ff f0 stwu r1,-16(r1)
ffc0c0f8: 7c 08 02 a6 mflr r0
int status;
status = sigtimedwait( set, NULL, NULL );
ffc0c0fc: 38 a0 00 00 li r5,0
int sigwait(
const sigset_t *set,
int *sig
)
{
ffc0c100: 93 e1 00 0c stw r31,12(r1)
ffc0c104: 7c 9f 23 78 mr r31,r4
int status;
status = sigtimedwait( set, NULL, NULL );
ffc0c108: 38 80 00 00 li r4,0
int sigwait(
const sigset_t *set,
int *sig
)
{
ffc0c10c: 90 01 00 14 stw r0,20(r1)
int status;
status = sigtimedwait( set, NULL, NULL );
ffc0c110: 4b ff fd 19 bl ffc0be28 <sigtimedwait>
if ( status != -1 ) {
ffc0c114: 2f 83 ff ff cmpwi cr7,r3,-1
int *sig
)
{
int status;
status = sigtimedwait( set, NULL, NULL );
ffc0c118: 7c 60 1b 78 mr r0,r3
if ( status != -1 ) {
ffc0c11c: 41 9e 00 28 beq- cr7,ffc0c144 <sigwait+0x50>
if ( sig )
ffc0c120: 2f 9f 00 00 cmpwi cr7,r31,0
*sig = status;
return 0;
ffc0c124: 38 60 00 00 li r3,0
int status;
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
ffc0c128: 41 9e 00 08 beq- cr7,ffc0c130 <sigwait+0x3c> <== NEVER TAKEN
*sig = status;
ffc0c12c: 90 1f 00 00 stw r0,0(r31)
return 0;
}
return errno;
}
ffc0c130: 80 01 00 14 lwz r0,20(r1)
ffc0c134: 83 e1 00 0c lwz r31,12(r1)
ffc0c138: 38 21 00 10 addi r1,r1,16
ffc0c13c: 7c 08 03 a6 mtlr r0
ffc0c140: 4e 80 00 20 blr
if ( sig )
*sig = status;
return 0;
}
return errno;
ffc0c144: 48 00 b0 95 bl ffc171d8 <__errno>
}
ffc0c148: 80 01 00 14 lwz r0,20(r1)
if ( sig )
*sig = status;
return 0;
}
return errno;
ffc0c14c: 80 63 00 00 lwz r3,0(r3)
}
ffc0c150: 7c 08 03 a6 mtlr r0
ffc0c154: 83 e1 00 0c lwz r31,12(r1)
ffc0c158: 38 21 00 10 addi r1,r1,16
ffc0c15c: 4e 80 00 20 blr
ffc07968 <siproc>:
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
ffc07968: 94 21 ff f0 stwu r1,-16(r1)
ffc0796c: 7c 08 02 a6 mflr r0
ffc07970: 90 01 00 14 stw r0,20(r1)
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
ffc07974: 80 04 00 3c lwz r0,60(r4)
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
ffc07978: 93 c1 00 08 stw r30,8(r1)
ffc0797c: 7c 7e 1b 78 mr r30,r3
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
ffc07980: 70 09 0e 78 andi. r9,r0,3704
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
ffc07984: 93 e1 00 0c stw r31,12(r1)
ffc07988: 7c 9f 23 78 mr r31,r4
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
ffc0798c: 40 82 00 1c bne- ffc079a8 <siproc+0x40> <== ALWAYS TAKEN
}
else {
i = iproc (c, tty);
}
return i;
}
ffc07990: 80 01 00 14 lwz r0,20(r1) <== NOT EXECUTED
ffc07994: 83 c1 00 08 lwz r30,8(r1) <== NOT EXECUTED
ffc07998: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc0799c: 83 e1 00 0c lwz r31,12(r1) <== NOT EXECUTED
ffc079a0: 38 21 00 10 addi r1,r1,16 <== NOT EXECUTED
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
i = iproc (c, tty);
rtems_semaphore_release (tty->osem);
}
else {
i = iproc (c, tty);
ffc079a4: 4b ff fd d8 b ffc0777c <iproc> <== NOT EXECUTED
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
ffc079a8: 80 64 00 18 lwz r3,24(r4)
ffc079ac: 38 a0 00 00 li r5,0
ffc079b0: 38 80 00 00 li r4,0
ffc079b4: 48 00 1a 25 bl ffc093d8 <rtems_semaphore_obtain>
i = iproc (c, tty);
ffc079b8: 7f e4 fb 78 mr r4,r31
ffc079bc: 7f c3 f3 78 mr r3,r30
ffc079c0: 4b ff fd bd bl ffc0777c <iproc>
ffc079c4: 7c 7e 1b 78 mr r30,r3
rtems_semaphore_release (tty->osem);
ffc079c8: 80 7f 00 18 lwz r3,24(r31)
ffc079cc: 48 00 1b 99 bl ffc09564 <rtems_semaphore_release>
}
else {
i = iproc (c, tty);
}
return i;
}
ffc079d0: 80 01 00 14 lwz r0,20(r1)
ffc079d4: 7f c3 f3 78 mr r3,r30
ffc079d8: 83 e1 00 0c lwz r31,12(r1)
ffc079dc: 7c 08 03 a6 mtlr r0
ffc079e0: 83 c1 00 08 lwz r30,8(r1)
ffc079e4: 38 21 00 10 addi r1,r1,16
ffc079e8: 4e 80 00 20 blr
ffc08e28 <statvfs>:
#include <sys/statvfs.h>
int
statvfs (const char *path, struct statvfs *sb)
{
ffc08e28: 94 21 ff d0 stwu r1,-48(r1)
ffc08e2c: 7c 08 02 a6 mflr r0
ffc08e30: 93 c1 00 28 stw r30,40(r1)
ffc08e34: 7c 7e 1b 78 mr r30,r3
ffc08e38: 90 01 00 34 stw r0,52(r1)
ffc08e3c: 93 e1 00 2c stw r31,44(r1)
ffc08e40: 7c 9f 23 78 mr r31,r4
* 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 ) )
ffc08e44: 48 01 00 f1 bl ffc18f34 <strlen>
ffc08e48: 38 a0 00 00 li r5,0
ffc08e4c: 7c 64 1b 78 mr r4,r3
ffc08e50: 38 c1 00 08 addi r6,r1,8
ffc08e54: 7f c3 f3 78 mr r3,r30
ffc08e58: 38 e0 00 01 li r7,1
ffc08e5c: 4b ff e6 3d bl ffc07498 <rtems_filesystem_evaluate_path>
return -1;
ffc08e60: 3b c0 ff ff li r30,-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 ) )
ffc08e64: 2f 83 00 00 cmpwi cr7,r3,0
ffc08e68: 40 9e 00 3c bne- cr7,ffc08ea4 <statvfs+0x7c> <== NEVER TAKEN
return -1;
mt_entry = loc.mt_entry;
ffc08e6c: 83 c1 00 18 lwz r30,24(r1)
fs_mount_root = &mt_entry->mt_fs_root;
memset (sb, 0, sizeof (struct statvfs));
ffc08e70: 38 80 00 00 li r4,0
ffc08e74: 38 a0 00 38 li r5,56
ffc08e78: 7f e3 fb 78 mr r3,r31
ffc08e7c: 48 00 ee 8d bl ffc17d08 <memset>
result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );
ffc08e80: 81 3e 00 28 lwz r9,40(r30)
ffc08e84: 38 7e 00 1c addi r3,r30,28
ffc08e88: 80 09 00 44 lwz r0,68(r9)
ffc08e8c: 7f e4 fb 78 mr r4,r31
ffc08e90: 7c 09 03 a6 mtctr r0
ffc08e94: 4e 80 04 21 bctrl
ffc08e98: 7c 7e 1b 78 mr r30,r3
rtems_filesystem_freenode( &loc );
ffc08e9c: 38 61 00 08 addi r3,r1,8
ffc08ea0: 4b ff e7 55 bl ffc075f4 <rtems_filesystem_freenode>
return result;
}
ffc08ea4: 80 01 00 34 lwz r0,52(r1)
ffc08ea8: 7f c3 f3 78 mr r3,r30
ffc08eac: 83 e1 00 2c lwz r31,44(r1)
ffc08eb0: 7c 08 03 a6 mtlr r0
ffc08eb4: 83 c1 00 28 lwz r30,40(r1)
ffc08eb8: 38 21 00 30 addi r1,r1,48
ffc08ebc: 4e 80 00 20 blr
ffc0762c <sync_per_thread>:
fdatasync(fn);
}
/* iterate over all FILE *'s for this thread */
static void sync_per_thread(Thread_Control *t)
{
ffc0762c: 94 21 ff f0 stwu r1,-16(r1)
ffc07630: 7c 08 02 a6 mflr r0
ffc07634: 90 01 00 14 stw r0,20(r1)
/*
* The sync_wrapper() function will operate on the current thread's
* reent structure so we will temporarily use that.
*/
this_reent = t->libc_reent;
ffc07638: 80 03 01 2c lwz r0,300(r3)
fdatasync(fn);
}
/* iterate over all FILE *'s for this thread */
static void sync_per_thread(Thread_Control *t)
{
ffc0763c: 93 c1 00 08 stw r30,8(r1)
/*
* The sync_wrapper() function will operate on the current thread's
* reent structure so we will temporarily use that.
*/
this_reent = t->libc_reent;
if ( this_reent ) {
ffc07640: 2f 80 00 00 cmpwi cr7,r0,0
fdatasync(fn);
}
/* iterate over all FILE *'s for this thread */
static void sync_per_thread(Thread_Control *t)
{
ffc07644: 93 e1 00 0c stw r31,12(r1)
/*
* The sync_wrapper() function will operate on the current thread's
* reent structure so we will temporarily use that.
*/
this_reent = t->libc_reent;
if ( this_reent ) {
ffc07648: 41 9e 00 30 beq- cr7,ffc07678 <sync_per_thread+0x4c> <== NEVER TAKEN
current_reent = _Thread_Executing->libc_reent;
ffc0764c: 3f e0 00 00 lis r31,0
ffc07650: 3b ff 31 24 addi r31,r31,12580
ffc07654: 81 3f 00 0c lwz r9,12(r31)
_Thread_Executing->libc_reent = this_reent;
_fwalk (t->libc_reent, sync_wrapper);
ffc07658: 3c 80 ff c0 lis r4,-64
ffc0765c: 38 84 76 90 addi r4,r4,30352
* The sync_wrapper() function will operate on the current thread's
* reent structure so we will temporarily use that.
*/
this_reent = t->libc_reent;
if ( this_reent ) {
current_reent = _Thread_Executing->libc_reent;
ffc07660: 83 c9 01 2c lwz r30,300(r9)
_Thread_Executing->libc_reent = this_reent;
ffc07664: 90 09 01 2c stw r0,300(r9)
_fwalk (t->libc_reent, sync_wrapper);
ffc07668: 80 63 01 2c lwz r3,300(r3)
ffc0766c: 48 00 e7 69 bl ffc15dd4 <_fwalk>
_Thread_Executing->libc_reent = current_reent;
ffc07670: 81 3f 00 0c lwz r9,12(r31)
ffc07674: 93 c9 01 2c stw r30,300(r9)
}
}
ffc07678: 80 01 00 14 lwz r0,20(r1)
ffc0767c: 83 c1 00 08 lwz r30,8(r1)
ffc07680: 7c 08 03 a6 mtlr r0
ffc07684: 83 e1 00 0c lwz r31,12(r1)
ffc07688: 38 21 00 10 addi r1,r1,16
ffc0768c: 4e 80 00 20 blr
ffc112d0 <tcsetattr>:
int fd,
int opt,
struct termios *tp
)
{
switch (opt) {
ffc112d0: 2c 04 00 00 cmpwi r4,0
int tcsetattr(
int fd,
int opt,
struct termios *tp
)
{
ffc112d4: 94 21 ff f0 stwu r1,-16(r1)
ffc112d8: 7c 08 02 a6 mflr r0
ffc112dc: 93 c1 00 08 stw r30,8(r1)
ffc112e0: 7c 7e 1b 78 mr r30,r3
ffc112e4: 93 e1 00 0c stw r31,12(r1)
ffc112e8: 7c bf 2b 78 mr r31,r5
ffc112ec: 90 01 00 14 stw r0,20(r1)
switch (opt) {
ffc112f0: 41 82 00 50 beq- ffc11340 <tcsetattr+0x70>
ffc112f4: 2f 84 00 01 cmpwi cr7,r4,1
ffc112f8: 41 9e 00 2c beq- cr7,ffc11324 <tcsetattr+0x54>
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
ffc112fc: 48 00 4e 85 bl ffc16180 <__errno>
ffc11300: 38 00 00 86 li r0,134
ffc11304: 90 03 00 00 stw r0,0(r3)
ffc11308: 38 60 ff ff li r3,-1
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
}
}
ffc1130c: 80 01 00 14 lwz r0,20(r1)
ffc11310: 83 c1 00 08 lwz r30,8(r1)
ffc11314: 7c 08 03 a6 mtlr r0
ffc11318: 83 e1 00 0c lwz r31,12(r1)
ffc1131c: 38 21 00 10 addi r1,r1,16
ffc11320: 4e 80 00 20 blr
switch (opt) {
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
ffc11324: 38 80 00 03 li r4,3
ffc11328: 38 a0 00 00 li r5,0
ffc1132c: 4c c6 31 82 crclr 4*cr1+eq
ffc11330: 4b ff fa 01 bl ffc10d30 <ioctl>
ffc11334: 2f 83 00 00 cmpwi cr7,r3,0
return -1;
ffc11338: 38 60 ff ff li r3,-1
switch (opt) {
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
ffc1133c: 41 9c 00 18 blt- cr7,ffc11354 <tcsetattr+0x84> <== NEVER TAKEN
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
ffc11340: 7f c3 f3 78 mr r3,r30
ffc11344: 38 80 00 02 li r4,2
ffc11348: 7f e5 fb 78 mr r5,r31
ffc1134c: 4c c6 31 82 crclr 4*cr1+eq
ffc11350: 4b ff f9 e1 bl ffc10d30 <ioctl>
}
}
ffc11354: 80 01 00 14 lwz r0,20(r1)
ffc11358: 83 c1 00 08 lwz r30,8(r1)
ffc1135c: 7c 08 03 a6 mtlr r0
ffc11360: 83 e1 00 0c lwz r31,12(r1)
ffc11364: 38 21 00 10 addi r1,r1,16
ffc11368: 4e 80 00 20 blr
ffc08ce0 <timer_create>:
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
ffc08ce0: 7d 80 00 26 mfcr r12
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
ffc08ce4: 2f 83 00 01 cmpwi cr7,r3,1
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
ffc08ce8: 94 21 ff e8 stwu r1,-24(r1)
ffc08cec: 7c 08 02 a6 mflr r0
ffc08cf0: 93 c1 00 10 stw r30,16(r1)
ffc08cf4: 7c be 2b 78 mr r30,r5
ffc08cf8: 93 e1 00 14 stw r31,20(r1)
ffc08cfc: 7c 9f 23 78 mr r31,r4
ffc08d00: 90 01 00 1c stw r0,28(r1)
ffc08d04: 93 a1 00 0c stw r29,12(r1)
ffc08d08: 91 81 00 08 stw r12,8(r1)
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
ffc08d0c: 40 9e 01 08 bne- cr7,ffc08e14 <timer_create+0x134>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
ffc08d10: 2f 85 00 00 cmpwi cr7,r5,0
ffc08d14: 41 9e 01 00 beq- cr7,ffc08e14 <timer_create+0x134>
/*
* The data of the structure evp are checked in order to verify if they
* are coherent.
*/
if (evp != NULL) {
ffc08d18: 2e 04 00 00 cmpwi cr4,r4,0
ffc08d1c: 41 92 00 2c beq- cr4,ffc08d48 <timer_create+0x68>
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
ffc08d20: 81 24 00 00 lwz r9,0(r4)
ffc08d24: 38 09 ff ff addi r0,r9,-1
ffc08d28: 2b 80 00 01 cmplwi cr7,r0,1
ffc08d2c: 41 9d 00 e8 bgt- cr7,ffc08e14 <timer_create+0x134> <== NEVER TAKEN
( evp->sigev_notify != SIGEV_SIGNAL ) ) {
/* The value of the field sigev_notify is not valid */
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !evp->sigev_signo )
ffc08d30: 81 24 00 04 lwz r9,4(r4)
ffc08d34: 2f 89 00 00 cmpwi cr7,r9,0
ffc08d38: 41 9e 00 dc beq- cr7,ffc08e14 <timer_create+0x134> <== NEVER TAKEN
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
ffc08d3c: 39 29 ff ff addi r9,r9,-1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
ffc08d40: 2b 89 00 1f cmplwi cr7,r9,31
ffc08d44: 41 9d 00 d0 bgt- cr7,ffc08e14 <timer_create+0x134> <== NEVER TAKEN
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc08d48: 3d 20 00 00 lis r9,0
ffc08d4c: 81 69 28 54 lwz r11,10324(r9)
ffc08d50: 38 0b 00 01 addi r0,r11,1
ffc08d54: 90 09 28 54 stw r0,10324(r9)
return _Thread_Dispatch_disable_level;
ffc08d58: 80 09 28 54 lwz r0,10324(r9)
* 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 );
ffc08d5c: 3f a0 00 00 lis r29,0
ffc08d60: 3b bd 2f 2c addi r29,r29,12076
ffc08d64: 7f a3 eb 78 mr r3,r29
ffc08d68: 48 00 28 3d bl ffc0b5a4 <_Objects_Allocate>
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
ffc08d6c: 2c 03 00 00 cmpwi r3,0
ffc08d70: 41 82 00 d8 beq- ffc08e48 <timer_create+0x168>
rtems_set_errno_and_return_minus_one( EAGAIN );
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
ffc08d74: 38 00 00 02 li r0,2
ffc08d78: 98 03 00 3c stb r0,60(r3)
ptimer->thread_id = _Thread_Executing->Object.id;
ffc08d7c: 3d 20 00 00 lis r9,0
ffc08d80: 81 29 31 70 lwz r9,12656(r9)
ffc08d84: 80 09 00 08 lwz r0,8(r9)
ffc08d88: 90 03 00 38 stw r0,56(r3)
if ( evp != NULL ) {
ffc08d8c: 41 92 00 1c beq- cr4,ffc08da8 <timer_create+0xc8>
ptimer->inf.sigev_notify = evp->sigev_notify;
ffc08d90: 81 7f 00 00 lwz r11,0(r31)
ptimer->inf.sigev_signo = evp->sigev_signo;
ffc08d94: 81 3f 00 04 lwz r9,4(r31)
ptimer->inf.sigev_value = evp->sigev_value;
ffc08d98: 80 1f 00 08 lwz r0,8(r31)
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
ptimer->thread_id = _Thread_Executing->Object.id;
if ( evp != NULL ) {
ptimer->inf.sigev_notify = evp->sigev_notify;
ffc08d9c: 91 63 00 40 stw r11,64(r3)
ptimer->inf.sigev_signo = evp->sigev_signo;
ffc08da0: 91 23 00 44 stw r9,68(r3)
ptimer->inf.sigev_value = evp->sigev_value;
ffc08da4: 90 03 00 48 stw r0,72(r3)
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
ffc08da8: 81 23 00 08 lwz r9,8(r3)
}
ptimer->overrun = 0;
ffc08dac: 38 00 00 00 li r0,0
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
ffc08db0: 81 5d 00 1c lwz r10,28(r29)
ffc08db4: 55 2b 13 ba rlwinm r11,r9,2,14,29
ffc08db8: 90 03 00 68 stw r0,104(r3)
ptimer->timer_data.it_value.tv_sec = 0;
ffc08dbc: 90 03 00 5c stw r0,92(r3)
ptimer->timer_data.it_value.tv_nsec = 0;
ffc08dc0: 90 03 00 60 stw r0,96(r3)
ptimer->timer_data.it_interval.tv_sec = 0;
ffc08dc4: 90 03 00 54 stw r0,84(r3)
ptimer->timer_data.it_interval.tv_nsec = 0;
ffc08dc8: 90 03 00 58 stw r0,88(r3)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
ffc08dcc: 90 03 00 18 stw r0,24(r3)
the_watchdog->routine = routine;
ffc08dd0: 90 03 00 2c stw r0,44(r3)
the_watchdog->id = id;
ffc08dd4: 90 03 00 30 stw r0,48(r3)
the_watchdog->user_data = user_data;
ffc08dd8: 90 03 00 34 stw r0,52(r3)
ffc08ddc: 7c 6a 59 2e stwx r3,r10,r11
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
ffc08de0: 90 03 00 0c stw r0,12(r3)
_Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL );
_Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0);
*timerid = ptimer->Object.id;
ffc08de4: 91 3e 00 00 stw r9,0(r30)
_Thread_Enable_dispatch();
ffc08de8: 48 00 3e 8d bl ffc0cc74 <_Thread_Enable_dispatch>
return 0;
ffc08dec: 38 60 00 00 li r3,0
}
ffc08df0: 80 01 00 1c lwz r0,28(r1)
ffc08df4: 81 81 00 08 lwz r12,8(r1)
ffc08df8: 7c 08 03 a6 mtlr r0
ffc08dfc: 83 a1 00 0c lwz r29,12(r1)
ffc08e00: 83 c1 00 10 lwz r30,16(r1)
ffc08e04: 7d 80 81 20 mtcrf 8,r12
ffc08e08: 83 e1 00 14 lwz r31,20(r1)
ffc08e0c: 38 21 00 18 addi r1,r1,24
ffc08e10: 4e 80 00 20 blr
if ( !evp->sigev_signo )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
rtems_set_errno_and_return_minus_one( EINVAL );
ffc08e14: 48 00 ba c5 bl ffc148d8 <__errno>
ffc08e18: 38 00 00 16 li r0,22
ffc08e1c: 90 03 00 00 stw r0,0(r3)
ffc08e20: 38 60 ff ff li r3,-1
_Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0);
*timerid = ptimer->Object.id;
_Thread_Enable_dispatch();
return 0;
}
ffc08e24: 80 01 00 1c lwz r0,28(r1)
ffc08e28: 81 81 00 08 lwz r12,8(r1)
ffc08e2c: 7c 08 03 a6 mtlr r0
ffc08e30: 83 a1 00 0c lwz r29,12(r1)
ffc08e34: 83 c1 00 10 lwz r30,16(r1)
ffc08e38: 7d 80 81 20 mtcrf 8,r12
ffc08e3c: 83 e1 00 14 lwz r31,20(r1)
ffc08e40: 38 21 00 18 addi r1,r1,24
ffc08e44: 4e 80 00 20 blr
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
_Thread_Enable_dispatch();
ffc08e48: 48 00 3e 2d bl ffc0cc74 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
ffc08e4c: 48 00 ba 8d bl ffc148d8 <__errno>
ffc08e50: 38 00 00 0b li r0,11
ffc08e54: 90 03 00 00 stw r0,0(r3)
ffc08e58: 38 60 ff ff li r3,-1
ffc08e5c: 4b ff ff 94 b ffc08df0 <timer_create+0x110>
ffc08e60 <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
ffc08e60: 94 21 ff c8 stwu r1,-56(r1)
ffc08e64: 7c 08 02 a6 mflr r0
ffc08e68: 93 a1 00 2c stw r29,44(r1)
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
ffc08e6c: 7c bd 2b 79 mr. r29,r5
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
ffc08e70: 93 81 00 28 stw r28,40(r1)
ffc08e74: 7c 9c 23 78 mr r28,r4
ffc08e78: 93 c1 00 30 stw r30,48(r1)
ffc08e7c: 7c de 33 78 mr r30,r6
ffc08e80: 93 e1 00 34 stw r31,52(r1)
ffc08e84: 7c 7f 1b 78 mr r31,r3
ffc08e88: 90 01 00 3c stw r0,60(r1)
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
ffc08e8c: 41 82 01 b8 beq- ffc09044 <timer_settime+0x1e4> <== 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) ) ) {
ffc08e90: 38 7d 00 08 addi r3,r29,8
ffc08e94: 48 00 4c 21 bl ffc0dab4 <_Timespec_Is_valid>
ffc08e98: 2f 83 00 00 cmpwi cr7,r3,0
ffc08e9c: 41 9e 01 a8 beq- cr7,ffc09044 <timer_settime+0x1e4>
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
ffc08ea0: 7f a3 eb 78 mr r3,r29
ffc08ea4: 48 00 4c 11 bl ffc0dab4 <_Timespec_Is_valid>
ffc08ea8: 2f 83 00 00 cmpwi cr7,r3,0
ffc08eac: 41 9e 01 98 beq- cr7,ffc09044 <timer_settime+0x1e4> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
ffc08eb0: 2f 9c 00 04 cmpwi cr7,r28,4
ffc08eb4: 41 9e 01 20 beq- cr7,ffc08fd4 <timer_settime+0x174>
ffc08eb8: 2f 9c 00 00 cmpwi cr7,r28,0
ffc08ebc: 40 9e 01 88 bne- cr7,ffc09044 <timer_settime+0x1e4>
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
ffc08ec0: 80 1d 00 0c lwz r0,12(r29)
RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Get (
timer_t id,
Objects_Locations *location
)
{
return (POSIX_Timer_Control *)
ffc08ec4: 3c 60 00 00 lis r3,0
ffc08ec8: 81 5d 00 00 lwz r10,0(r29)
ffc08ecc: 7f e4 fb 78 mr r4,r31
ffc08ed0: 81 7d 00 04 lwz r11,4(r29)
ffc08ed4: 38 63 2f 2c addi r3,r3,12076
ffc08ed8: 81 3d 00 08 lwz r9,8(r29)
ffc08edc: 38 a1 00 08 addi r5,r1,8
ffc08ee0: 90 01 00 20 stw r0,32(r1)
ffc08ee4: 91 41 00 14 stw r10,20(r1)
ffc08ee8: 91 61 00 18 stw r11,24(r1)
ffc08eec: 91 21 00 1c stw r9,28(r1)
ffc08ef0: 48 00 2c a5 bl ffc0bb94 <_Objects_Get>
ffc08ef4: 7c 7f 1b 78 mr r31,r3
* something with the structure of times of the timer: to stop, start
* or start it again
*/
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
ffc08ef8: 80 01 00 08 lwz r0,8(r1)
ffc08efc: 2f 80 00 00 cmpwi cr7,r0,0
ffc08f00: 40 9e 01 44 bne- cr7,ffc09044 <timer_settime+0x1e4> <== NEVER TAKEN
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 ) {
ffc08f04: 80 01 00 1c lwz r0,28(r1)
ffc08f08: 2f 80 00 00 cmpwi cr7,r0,0
ffc08f0c: 40 9e 00 10 bne- cr7,ffc08f1c <timer_settime+0xbc>
ffc08f10: 80 01 00 20 lwz r0,32(r1)
ffc08f14: 2f 80 00 00 cmpwi cr7,r0,0
ffc08f18: 41 9e 01 40 beq- cr7,ffc09058 <timer_settime+0x1f8>
_Thread_Enable_dispatch();
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
ffc08f1c: 7f a3 eb 78 mr r3,r29
ffc08f20: 48 00 4c 1d bl ffc0db3c <_Timespec_To_ticks>
ffc08f24: 90 7f 00 64 stw r3,100(r31)
initial_period = _Timespec_To_ticks( &normalize.it_value );
ffc08f28: 38 61 00 1c addi r3,r1,28
ffc08f2c: 48 00 4c 11 bl ffc0db3c <_Timespec_To_ticks>
activated = _POSIX_Timer_Insert_helper(
ffc08f30: 80 bf 00 08 lwz r5,8(r31)
ffc08f34: 3c c0 ff c1 lis r6,-63
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 );
ffc08f38: 7c 64 1b 78 mr r4,r3
activated = _POSIX_Timer_Insert_helper(
ffc08f3c: 38 c6 90 d8 addi r6,r6,-28456
ffc08f40: 38 7f 00 10 addi r3,r31,16
ffc08f44: 7f e7 fb 78 mr r7,r31
ffc08f48: 48 00 81 41 bl ffc11088 <_POSIX_Timer_Insert_helper>
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
ffc08f4c: 2f 83 00 00 cmpwi cr7,r3,0
ffc08f50: 41 9e 00 5c beq- cr7,ffc08fac <timer_settime+0x14c>
/*
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
ffc08f54: 2f 9e 00 00 cmpwi cr7,r30,0
ffc08f58: 41 9e 00 24 beq- cr7,ffc08f7c <timer_settime+0x11c>
*ovalue = ptimer->timer_data;
ffc08f5c: 81 5f 00 54 lwz r10,84(r31)
ffc08f60: 81 7f 00 58 lwz r11,88(r31)
ffc08f64: 81 3f 00 5c lwz r9,92(r31)
ffc08f68: 80 1f 00 60 lwz r0,96(r31)
ffc08f6c: 91 5e 00 00 stw r10,0(r30)
ffc08f70: 91 7e 00 04 stw r11,4(r30)
ffc08f74: 91 3e 00 08 stw r9,8(r30)
ffc08f78: 90 1e 00 0c stw r0,12(r30)
ptimer->timer_data = normalize;
ffc08f7c: 80 01 00 14 lwz r0,20(r1)
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
_TOD_Get( &ptimer->time );
ffc08f80: 38 7f 00 6c addi r3,r31,108
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
*ovalue = ptimer->timer_data;
ptimer->timer_data = normalize;
ffc08f84: 90 1f 00 54 stw r0,84(r31)
ffc08f88: 80 01 00 18 lwz r0,24(r1)
ffc08f8c: 90 1f 00 58 stw r0,88(r31)
ffc08f90: 80 01 00 1c lwz r0,28(r1)
ffc08f94: 90 1f 00 5c stw r0,92(r31)
ffc08f98: 80 01 00 20 lwz r0,32(r1)
ffc08f9c: 90 1f 00 60 stw r0,96(r31)
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
ffc08fa0: 38 00 00 03 li r0,3
ffc08fa4: 98 1f 00 3c stb r0,60(r31)
_TOD_Get( &ptimer->time );
ffc08fa8: 48 00 1f a5 bl ffc0af4c <_TOD_Get>
_Thread_Enable_dispatch();
ffc08fac: 48 00 3c c9 bl ffc0cc74 <_Thread_Enable_dispatch>
return 0;
ffc08fb0: 38 60 00 00 li r3,0
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
ffc08fb4: 80 01 00 3c lwz r0,60(r1)
ffc08fb8: 83 81 00 28 lwz r28,40(r1)
ffc08fbc: 7c 08 03 a6 mtlr r0
ffc08fc0: 83 a1 00 2c lwz r29,44(r1)
ffc08fc4: 83 c1 00 30 lwz r30,48(r1)
ffc08fc8: 83 e1 00 34 lwz r31,52(r1)
ffc08fcc: 38 21 00 38 addi r1,r1,56
ffc08fd0: 4e 80 00 20 blr
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
ffc08fd4: 81 5d 00 00 lwz r10,0(r29)
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
struct timespec now;
_TOD_Get( &now );
ffc08fd8: 38 61 00 0c addi r3,r1,12
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
ffc08fdc: 81 7d 00 04 lwz r11,4(r29)
ffc08fe0: 81 3d 00 08 lwz r9,8(r29)
ffc08fe4: 80 1d 00 0c lwz r0,12(r29)
ffc08fe8: 91 41 00 14 stw r10,20(r1)
ffc08fec: 91 61 00 18 stw r11,24(r1)
ffc08ff0: 91 21 00 1c stw r9,28(r1)
ffc08ff4: 90 01 00 20 stw r0,32(r1)
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
struct timespec now;
_TOD_Get( &now );
ffc08ff8: 48 00 1f 55 bl ffc0af4c <_TOD_Get>
/* Check for seconds in the past */
if ( _Timespec_Greater_than( &now, &normalize.it_value ) )
ffc08ffc: 38 61 00 0c addi r3,r1,12
ffc09000: 38 81 00 1c addi r4,r1,28
ffc09004: 48 00 4a 75 bl ffc0da78 <_Timespec_Greater_than>
ffc09008: 2f 83 00 00 cmpwi cr7,r3,0
ffc0900c: 40 9e 00 38 bne- cr7,ffc09044 <timer_settime+0x1e4>
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value );
ffc09010: 38 81 00 1c addi r4,r1,28
ffc09014: 7c 85 23 78 mr r5,r4
ffc09018: 38 61 00 0c addi r3,r1,12
ffc0901c: 48 00 4a d5 bl ffc0daf0 <_Timespec_Subtract>
ffc09020: 3c 60 00 00 lis r3,0
ffc09024: 7f e4 fb 78 mr r4,r31
ffc09028: 38 63 2f 2c addi r3,r3,12076
ffc0902c: 38 a1 00 08 addi r5,r1,8
ffc09030: 48 00 2b 65 bl ffc0bb94 <_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 ) {
ffc09034: 80 01 00 08 lwz r0,8(r1)
ffc09038: 7c 7f 1b 78 mr r31,r3
ffc0903c: 2f 80 00 00 cmpwi cr7,r0,0
ffc09040: 41 be fe c4 beq- cr7,ffc08f04 <timer_settime+0xa4>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
ffc09044: 48 00 b8 95 bl ffc148d8 <__errno>
ffc09048: 38 00 00 16 li r0,22
ffc0904c: 90 03 00 00 stw r0,0(r3)
ffc09050: 38 60 ff ff li r3,-1
ffc09054: 4b ff ff 60 b ffc08fb4 <timer_settime+0x154>
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 ) {
/* Stop the timer */
(void) _Watchdog_Remove( &ptimer->Timer );
ffc09058: 38 63 00 10 addi r3,r3,16
ffc0905c: 48 00 51 e9 bl ffc0e244 <_Watchdog_Remove>
/* The old data of the timer are returned */
if ( ovalue )
ffc09060: 2f 9e 00 00 cmpwi cr7,r30,0
ffc09064: 41 9e 00 24 beq- cr7,ffc09088 <timer_settime+0x228>
*ovalue = ptimer->timer_data;
ffc09068: 81 5f 00 54 lwz r10,84(r31)
ffc0906c: 81 7f 00 58 lwz r11,88(r31)
ffc09070: 81 3f 00 5c lwz r9,92(r31)
ffc09074: 80 1f 00 60 lwz r0,96(r31)
ffc09078: 91 5e 00 00 stw r10,0(r30)
ffc0907c: 91 7e 00 04 stw r11,4(r30)
ffc09080: 91 3e 00 08 stw r9,8(r30)
ffc09084: 90 1e 00 0c stw r0,12(r30)
/* The new data are set */
ptimer->timer_data = normalize;
ffc09088: 80 01 00 14 lwz r0,20(r1)
ffc0908c: 90 1f 00 54 stw r0,84(r31)
ffc09090: 80 01 00 18 lwz r0,24(r1)
ffc09094: 90 1f 00 58 stw r0,88(r31)
ffc09098: 80 01 00 1c lwz r0,28(r1)
ffc0909c: 90 1f 00 5c stw r0,92(r31)
ffc090a0: 80 01 00 20 lwz r0,32(r1)
ffc090a4: 90 1f 00 60 stw r0,96(r31)
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
ffc090a8: 38 00 00 04 li r0,4
ffc090ac: 98 1f 00 3c stb r0,60(r31)
/* Returns with success */
_Thread_Enable_dispatch();
ffc090b0: 48 00 3b c5 bl ffc0cc74 <_Thread_Enable_dispatch>
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
ffc090b4: 80 01 00 3c lwz r0,60(r1)
ptimer->timer_data = normalize;
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
/* Returns with success */
_Thread_Enable_dispatch();
return 0;
ffc090b8: 38 60 00 00 li r3,0
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
ffc090bc: 83 81 00 28 lwz r28,40(r1)
ffc090c0: 7c 08 03 a6 mtlr r0
ffc090c4: 83 a1 00 2c lwz r29,44(r1)
ffc090c8: 83 c1 00 30 lwz r30,48(r1)
ffc090cc: 83 e1 00 34 lwz r31,52(r1)
ffc090d0: 38 21 00 38 addi r1,r1,56
ffc090d4: 4e 80 00 20 blr
ffc08c28 <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
ffc08c28: 94 21 ff d8 stwu r1,-40(r1)
ffc08c2c: 7c 08 02 a6 mflr r0
ffc08c30: 93 e1 00 24 stw r31,36(r1)
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
ffc08c34: 3f e0 00 00 lis r31,0
ffc08c38: 3b ff 35 74 addi r31,r31,13684
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
ffc08c3c: 90 01 00 2c stw r0,44(r1)
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
ffc08c40: 80 1f 00 1c lwz r0,28(r31)
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
ffc08c44: 93 c1 00 20 stw r30,32(r1)
ffc08c48: 7c 7e 1b 78 mr r30,r3
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
ffc08c4c: 2f 80 00 00 cmpwi cr7,r0,0
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
ffc08c50: 93 a1 00 1c stw r29,28(r1)
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
ffc08c54: 41 9e 00 a4 beq- cr7,ffc08cf8 <ualarm+0xd0>
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
ffc08c58: 7f e3 fb 78 mr r3,r31
ffc08c5c: 48 00 50 c9 bl ffc0dd24 <_Watchdog_Remove>
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
ffc08c60: 3b a0 00 00 li r29,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) ) {
ffc08c64: 38 63 ff fe addi r3,r3,-2
ffc08c68: 2b 83 00 01 cmplwi cr7,r3,1
ffc08c6c: 40 9d 00 ac ble- cr7,ffc08d18 <ualarm+0xf0> <== ALWAYS TAKEN
/*
* 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 ) {
ffc08c70: 2f 9e 00 00 cmpwi cr7,r30,0
ffc08c74: 41 be 00 64 beq+ cr7,ffc08cd8 <ualarm+0xb0>
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
ffc08c78: 3c 00 43 1b lis r0,17179
ffc08c7c: 60 00 de 83 ori r0,r0,56963
ffc08c80: 7c 1e 00 16 mulhwu r0,r30,r0
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
ticks = _Timespec_To_ticks( &tp );
ffc08c84: 38 61 00 08 addi r3,r1,8
* 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;
ffc08c88: 54 00 74 be rlwinm r0,r0,14,18,31
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
ffc08c8c: 54 0b 40 2e rlwinm r11,r0,8,0,23
* 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;
ffc08c90: 90 01 00 08 stw r0,8(r1)
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
ffc08c94: 54 09 18 38 rlwinm r9,r0,3,0,28
ffc08c98: 7d 29 58 50 subf r9,r9,r11
ffc08c9c: 55 2b 30 32 rlwinm r11,r9,6,0,25
ffc08ca0: 7d 29 58 50 subf r9,r9,r11
ffc08ca4: 7d 29 02 14 add r9,r9,r0
ffc08ca8: 55 29 30 32 rlwinm r9,r9,6,0,25
ffc08cac: 7f c9 f0 50 subf r30,r9,r30
ffc08cb0: 1f de 03 e8 mulli r30,r30,1000
ffc08cb4: 93 c1 00 0c stw r30,12(r1)
ticks = _Timespec_To_ticks( &tp );
ffc08cb8: 48 00 48 49 bl ffc0d500 <_Timespec_To_ticks>
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
ffc08cbc: 38 61 00 08 addi r3,r1,8
ffc08cc0: 48 00 48 41 bl ffc0d500 <_Timespec_To_ticks>
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
ffc08cc4: 7f e4 fb 78 mr r4,r31
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
ffc08cc8: 90 7f 00 0c stw r3,12(r31)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
ffc08ccc: 3c 60 00 00 lis r3,0
ffc08cd0: 38 63 2d a8 addi r3,r3,11688
ffc08cd4: 48 00 4e 89 bl ffc0db5c <_Watchdog_Insert>
}
return remaining;
}
ffc08cd8: 80 01 00 2c lwz r0,44(r1)
ffc08cdc: 7f a3 eb 78 mr r3,r29
ffc08ce0: 83 c1 00 20 lwz r30,32(r1)
ffc08ce4: 7c 08 03 a6 mtlr r0
ffc08ce8: 83 a1 00 1c lwz r29,28(r1)
ffc08cec: 83 e1 00 24 lwz r31,36(r1)
ffc08cf0: 38 21 00 28 addi r1,r1,40
ffc08cf4: 4e 80 00 20 blr
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
ffc08cf8: 3d 20 ff c1 lis r9,-63
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
ffc08cfc: 90 1f 00 08 stw r0,8(r31)
the_watchdog->routine = routine;
ffc08d00: 39 29 8b d8 addi r9,r9,-29736
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
ffc08d04: 3b a0 00 00 li r29,0
ffc08d08: 91 3f 00 1c stw r9,28(r31)
the_watchdog->id = id;
ffc08d0c: 90 1f 00 20 stw r0,32(r31)
the_watchdog->user_data = user_data;
ffc08d10: 90 1f 00 24 stw r0,36(r31)
ffc08d14: 4b ff ff 5c b ffc08c70 <ualarm+0x48>
* 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);
ffc08d18: 81 3f 00 0c lwz r9,12(r31)
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
ffc08d1c: 38 81 00 08 addi r4,r1,8
* 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);
ffc08d20: 80 7f 00 14 lwz r3,20(r31)
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
remaining += tp.tv_nsec / 1000;
ffc08d24: 3f a0 10 62 lis r29,4194
* 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);
ffc08d28: 80 1f 00 18 lwz r0,24(r31)
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
remaining += tp.tv_nsec / 1000;
ffc08d2c: 63 bd 4d d3 ori r29,r29,19923
* 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);
ffc08d30: 7c 63 4a 14 add r3,r3,r9
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
ffc08d34: 7c 60 18 50 subf r3,r0,r3
ffc08d38: 48 00 47 31 bl ffc0d468 <_Timespec_From_ticks>
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
ffc08d3c: 80 01 00 08 lwz r0,8(r1)
remaining += tp.tv_nsec / 1000;
ffc08d40: 81 21 00 0c lwz r9,12(r1)
ticks = the_timer->initial;
ticks -= (the_timer->stop_time - the_timer->start_time);
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
ffc08d44: 54 0a 40 2e rlwinm r10,r0,8,0,23
ffc08d48: 54 0b 18 38 rlwinm r11,r0,3,0,28
ffc08d4c: 7d 6b 50 50 subf r11,r11,r10
remaining += tp.tv_nsec / 1000;
ffc08d50: 7f a9 e8 96 mulhw r29,r9,r29
ticks = the_timer->initial;
ticks -= (the_timer->stop_time - the_timer->start_time);
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
ffc08d54: 55 6a 30 32 rlwinm r10,r11,6,0,25
ffc08d58: 7d 6b 50 50 subf r11,r11,r10
ffc08d5c: 7c 0b 02 14 add r0,r11,r0
remaining += tp.tv_nsec / 1000;
ffc08d60: 7f bd 36 70 srawi r29,r29,6
ffc08d64: 7d 29 fe 70 srawi r9,r9,31
ticks = the_timer->initial;
ticks -= (the_timer->stop_time - the_timer->start_time);
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
ffc08d68: 54 00 30 32 rlwinm r0,r0,6,0,25
remaining += tp.tv_nsec / 1000;
ffc08d6c: 7f a9 e8 50 subf r29,r9,r29
ffc08d70: 7f bd 02 14 add r29,r29,r0
ffc08d74: 4b ff fe fc b ffc08c70 <ualarm+0x48>
ffc093b4 <unlink>:
#include <rtems/seterr.h>
int unlink(
const char *path
)
{
ffc093b4: 94 21 ff b0 stwu r1,-80(r1)
ffc093b8: 7c 08 02 a6 mflr r0
ffc093bc: 93 a1 00 44 stw r29,68(r1)
ffc093c0: 93 c1 00 48 stw r30,72(r1)
*/
parentpathlen = rtems_filesystem_dirname ( path );
if ( parentpathlen == 0 )
rtems_filesystem_get_start_loc( path, &i, &parentloc );
ffc093c4: 3b c1 00 20 addi r30,r1,32
#include <rtems/seterr.h>
int unlink(
const char *path
)
{
ffc093c8: 93 e1 00 4c stw r31,76(r1)
ffc093cc: 7c 7f 1b 78 mr r31,r3
ffc093d0: 90 01 00 54 stw r0,84(r1)
ffc093d4: 93 61 00 3c stw r27,60(r1)
ffc093d8: 93 81 00 40 stw r28,64(r1)
/*
* Get the node to be unlinked. Find the parent path first.
*/
parentpathlen = rtems_filesystem_dirname ( path );
ffc093dc: 4b ff c8 35 bl ffc05c10 <rtems_filesystem_dirname>
if ( parentpathlen == 0 )
ffc093e0: 7c 7d 1b 79 mr. r29,r3
rtems_filesystem_get_start_loc( path, &i, &parentloc );
ffc093e4: 7f e3 fb 78 mr r3,r31
* Get the node to be unlinked. Find the parent path first.
*/
parentpathlen = rtems_filesystem_dirname ( path );
if ( parentpathlen == 0 )
ffc093e8: 40 82 00 b8 bne- ffc094a0 <unlink+0xec>
rtems_filesystem_get_start_loc( path, &i, &parentloc );
ffc093ec: 38 81 00 08 addi r4,r1,8
ffc093f0: 7f c5 f3 78 mr r5,r30
ffc093f4: 4b ff dc b9 bl ffc070ac <rtems_filesystem_get_start_loc>
ffc093f8: 3b a0 00 00 li r29,0
const char *name;
rtems_filesystem_location_info_t parentloc;
rtems_filesystem_location_info_t loc;
int i;
int result;
bool free_parentloc = false;
ffc093fc: 3b 80 00 00 li r28,0
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
ffc09400: 80 01 00 20 lwz r0,32(r1)
name = path + parentpathlen;
ffc09404: 7f ff ea 14 add r31,r31,r29
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
ffc09408: 7f e3 fb 78 mr r3,r31
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
ffc0940c: 90 01 00 0c stw r0,12(r1)
ffc09410: 80 01 00 24 lwz r0,36(r1)
ffc09414: 90 01 00 10 stw r0,16(r1)
ffc09418: 80 01 00 28 lwz r0,40(r1)
ffc0941c: 90 01 00 14 stw r0,20(r1)
ffc09420: 80 01 00 2c lwz r0,44(r1)
ffc09424: 90 01 00 18 stw r0,24(r1)
ffc09428: 80 01 00 30 lwz r0,48(r1)
ffc0942c: 90 01 00 1c stw r0,28(r1)
name = path + parentpathlen;
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
ffc09430: 48 01 02 6d bl ffc1969c <strlen>
ffc09434: 7c 64 1b 78 mr r4,r3
ffc09438: 7f e3 fb 78 mr r3,r31
ffc0943c: 4b ff c8 35 bl ffc05c70 <rtems_filesystem_prefix_separators>
ffc09440: 7f ff 1a 14 add r31,r31,r3
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
ffc09444: 7f e3 fb 78 mr r3,r31
ffc09448: 48 01 02 55 bl ffc1969c <strlen>
ffc0944c: 38 a0 00 00 li r5,0
ffc09450: 7c 64 1b 78 mr r4,r3
ffc09454: 38 c1 00 0c addi r6,r1,12
ffc09458: 7f e3 fb 78 mr r3,r31
ffc0945c: 38 e0 00 00 li r7,0
ffc09460: 4b ff c6 89 bl ffc05ae8 <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
ffc09464: 2f 83 00 00 cmpwi cr7,r3,0
ffc09468: 41 9e 00 60 beq- cr7,ffc094c8 <unlink+0x114>
if ( free_parentloc )
ffc0946c: 2f 9c 00 00 cmpwi cr7,r28,0
rtems_filesystem_freenode( &parentloc );
return -1;
ffc09470: 3b 60 ff ff li r27,-1
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 )
ffc09474: 40 9e 00 9c bne- cr7,ffc09510 <unlink+0x15c>
rtems_filesystem_freenode( &loc );
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return result;
}
ffc09478: 80 01 00 54 lwz r0,84(r1)
ffc0947c: 7f 63 db 78 mr r3,r27
ffc09480: 83 81 00 40 lwz r28,64(r1)
ffc09484: 7c 08 03 a6 mtlr r0
ffc09488: 83 61 00 3c lwz r27,60(r1)
ffc0948c: 83 a1 00 44 lwz r29,68(r1)
ffc09490: 83 c1 00 48 lwz r30,72(r1)
ffc09494: 83 e1 00 4c lwz r31,76(r1)
ffc09498: 38 21 00 50 addi r1,r1,80
ffc0949c: 4e 80 00 20 blr
parentpathlen = rtems_filesystem_dirname ( path );
if ( parentpathlen == 0 )
rtems_filesystem_get_start_loc( path, &i, &parentloc );
else {
result = rtems_filesystem_evaluate_path( path, parentpathlen,
ffc094a0: 7f a4 eb 78 mr r4,r29
ffc094a4: 38 a0 00 02 li r5,2
ffc094a8: 7f c6 f3 78 mr r6,r30
ffc094ac: 38 e0 00 00 li r7,0
ffc094b0: 4b ff c6 e5 bl ffc05b94 <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
return -1;
ffc094b4: 3b 60 ff ff li r27,-1
else {
result = rtems_filesystem_evaluate_path( path, parentpathlen,
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
ffc094b8: 2f 83 00 00 cmpwi cr7,r3,0
ffc094bc: 40 be ff bc bne- cr7,ffc09478 <unlink+0xc4> <== NEVER TAKEN
return -1;
free_parentloc = true;
ffc094c0: 3b 80 00 01 li r28,1
ffc094c4: 4b ff ff 3c b ffc09400 <unlink+0x4c>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return -1;
}
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) {
ffc094c8: 81 21 00 18 lwz r9,24(r1)
ffc094cc: 38 61 00 0c addi r3,r1,12
ffc094d0: 80 09 00 10 lwz r0,16(r9)
ffc094d4: 7c 09 03 a6 mtctr r0
ffc094d8: 4e 80 04 21 bctrl
ffc094dc: 2f 83 00 01 cmpwi cr7,r3,1
ffc094e0: 41 9e 00 60 beq- cr7,ffc09540 <unlink+0x18c>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
rtems_set_errno_and_return_minus_one( EISDIR );
}
result = (*loc.ops->unlink_h)( &parentloc, &loc );
ffc094e4: 81 21 00 18 lwz r9,24(r1)
ffc094e8: 38 81 00 0c addi r4,r1,12
ffc094ec: 7f c3 f3 78 mr r3,r30
ffc094f0: 80 09 00 0c lwz r0,12(r9)
ffc094f4: 7c 09 03 a6 mtctr r0
ffc094f8: 4e 80 04 21 bctrl
ffc094fc: 7c 7b 1b 78 mr r27,r3
rtems_filesystem_freenode( &loc );
ffc09500: 38 61 00 0c addi r3,r1,12
ffc09504: 4b ff c7 ed bl ffc05cf0 <rtems_filesystem_freenode>
if ( free_parentloc )
ffc09508: 2f 9c 00 00 cmpwi cr7,r28,0
ffc0950c: 41 9e ff 6c beq+ cr7,ffc09478 <unlink+0xc4>
rtems_filesystem_freenode( &parentloc );
ffc09510: 7f c3 f3 78 mr r3,r30
ffc09514: 4b ff c7 dd bl ffc05cf0 <rtems_filesystem_freenode>
return result;
}
ffc09518: 80 01 00 54 lwz r0,84(r1)
ffc0951c: 7f 63 db 78 mr r3,r27
ffc09520: 83 81 00 40 lwz r28,64(r1)
ffc09524: 7c 08 03 a6 mtlr r0
ffc09528: 83 61 00 3c lwz r27,60(r1)
ffc0952c: 83 a1 00 44 lwz r29,68(r1)
ffc09530: 83 c1 00 48 lwz r30,72(r1)
ffc09534: 83 e1 00 4c lwz r31,76(r1)
ffc09538: 38 21 00 50 addi r1,r1,80
ffc0953c: 4e 80 00 20 blr
rtems_filesystem_freenode( &parentloc );
return -1;
}
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) {
rtems_filesystem_freenode( &loc );
ffc09540: 38 61 00 0c addi r3,r1,12
ffc09544: 4b ff c7 ad bl ffc05cf0 <rtems_filesystem_freenode>
if ( free_parentloc )
ffc09548: 2f 9c 00 00 cmpwi cr7,r28,0
ffc0954c: 41 be 00 0c beq+ cr7,ffc09558 <unlink+0x1a4>
rtems_filesystem_freenode( &parentloc );
ffc09550: 7f c3 f3 78 mr r3,r30
ffc09554: 4b ff c7 9d bl ffc05cf0 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EISDIR );
ffc09558: 48 00 ef c9 bl ffc18520 <__errno>
ffc0955c: 38 00 00 15 li r0,21
ffc09560: 90 03 00 00 stw r0,0(r3)
ffc09564: 3b 60 ff ff li r27,-1
ffc09568: 4b ff ff 10 b ffc09478 <unlink+0xc4>
ffc0c87c <unmount>:
*/
int unmount(
const char *path
)
{
ffc0c87c: 94 21 ff d0 stwu r1,-48(r1)
ffc0c880: 7c 08 02 a6 mflr r0
ffc0c884: 93 e1 00 2c stw r31,44(r1)
ffc0c888: 7c 7f 1b 78 mr r31,r3
ffc0c88c: 90 01 00 34 stw r0,52(r1)
ffc0c890: 93 c1 00 28 stw r30,40(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 ) )
ffc0c894: 48 01 94 f9 bl ffc25d8c <strlen>
ffc0c898: 7c 64 1b 78 mr r4,r3
ffc0c89c: 38 a0 00 00 li r5,0
ffc0c8a0: 7f e3 fb 78 mr r3,r31
ffc0c8a4: 38 c1 00 08 addi r6,r1,8
ffc0c8a8: 38 e0 00 01 li r7,1
ffc0c8ac: 4b ff b9 29 bl ffc081d4 <rtems_filesystem_evaluate_path>
ffc0c8b0: 2f 83 00 00 cmpwi cr7,r3,0
ffc0c8b4: 40 9e 01 38 bne- cr7,ffc0c9ec <unmount+0x170>
return -1;
mt_entry = loc.mt_entry;
ffc0c8b8: 83 e1 00 18 lwz r31,24(r1)
/*
* Verify this is the root node for the file system to be unmounted.
*/
if ( fs_root_loc->node_access != loc.node_access ){
rtems_filesystem_freenode( &loc );
ffc0c8bc: 38 61 00 08 addi r3,r1,8
/*
* Verify this is the root node for the file system to be unmounted.
*/
if ( fs_root_loc->node_access != loc.node_access ){
ffc0c8c0: 80 01 00 08 lwz r0,8(r1)
ffc0c8c4: 81 3f 00 1c lwz r9,28(r31)
ffc0c8c8: 7f 89 00 00 cmpw cr7,r9,r0
ffc0c8cc: 40 9e 00 f4 bne- cr7,ffc0c9c0 <unmount+0x144>
/*
* Free the loc node and just use the nodes from the mt_entry .
*/
rtems_filesystem_freenode( &loc );
ffc0c8d0: 4b ff bb e5 bl ffc084b4 <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 )
ffc0c8d4: 3d 20 00 00 lis r9,0
ffc0c8d8: 81 29 27 dc lwz r9,10204(r9)
ffc0c8dc: 80 09 00 14 lwz r0,20(r9)
ffc0c8e0: 7f 80 f8 00 cmpw cr7,r0,r31
ffc0c8e4: 41 9e 01 24 beq- cr7,ffc0ca08 <unmount+0x18c>
/*
* Verify there are no file systems below the path specified
*/
if ( rtems_filesystem_mount_iterate( is_fs_below_mount_point,
ffc0c8e8: 80 9f 00 2c lwz r4,44(r31)
ffc0c8ec: 3c 60 ff c1 lis r3,-63
ffc0c8f0: 38 63 c8 68 addi r3,r3,-14232
ffc0c8f4: 4b ff c7 75 bl ffc09068 <rtems_filesystem_mount_iterate>
ffc0c8f8: 2f 83 00 00 cmpwi cr7,r3,0
ffc0c8fc: 40 9e 01 0c bne- cr7,ffc0ca08 <unmount+0x18c>
* 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 )
ffc0c900: 7f e3 fb 78 mr r3,r31
ffc0c904: 4b ff c0 1d bl ffc08920 <rtems_libio_is_open_files_in_fs>
ffc0c908: 2f 83 00 01 cmpwi cr7,r3,1
ffc0c90c: 41 9e 00 fc beq- cr7,ffc0ca08 <unmount+0x18c>
* 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 )
ffc0c910: 81 3f 00 14 lwz r9,20(r31)
ffc0c914: 7f e3 fb 78 mr r3,r31
ffc0c918: 80 09 00 28 lwz r0,40(r9)
ffc0c91c: 7c 09 03 a6 mtctr r0
ffc0c920: 4e 80 04 21 bctrl
ffc0c924: 2f 83 00 00 cmpwi cr7,r3,0
ffc0c928: 40 9e 00 c4 bne- cr7,ffc0c9ec <unmount+0x170> <== 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){
ffc0c92c: 81 3f 00 28 lwz r9,40(r31)
ffc0c930: 7f e3 fb 78 mr r3,r31
ffc0c934: 80 09 00 2c lwz r0,44(r9)
ffc0c938: 7c 09 03 a6 mtctr r0
ffc0c93c: 4e 80 04 21 bctrl
ffc0c940: 2f 83 00 00 cmpwi cr7,r3,0
ffc0c944: 40 9e 00 54 bne- cr7,ffc0c998 <unmount+0x11c> <== NEVER TAKEN
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 );
ffc0c948: 3f c0 00 00 lis r30,0
ffc0c94c: 80 7e 28 5c lwz r3,10332(r30)
ffc0c950: 38 80 00 00 li r4,0
ffc0c954: 38 a0 00 00 li r5,0
ffc0c958: 48 00 0e 35 bl ffc0d78c <rtems_semaphore_obtain>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
ffc0c95c: 7f e3 fb 78 mr r3,r31
ffc0c960: 48 00 1e 79 bl ffc0e7d8 <_Chain_Extract>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
ffc0c964: 80 7e 28 5c lwz r3,10332(r30)
ffc0c968: 48 00 0f b1 bl ffc0d918 <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 );
ffc0c96c: 38 7f 00 08 addi r3,r31,8
ffc0c970: 4b ff bb 45 bl ffc084b4 <rtems_filesystem_freenode>
free( mt_entry );
ffc0c974: 7f e3 fb 78 mr r3,r31
ffc0c978: 4b ff bb 69 bl ffc084e0 <free>
return 0;
ffc0c97c: 38 60 00 00 li r3,0
}
ffc0c980: 80 01 00 34 lwz r0,52(r1)
ffc0c984: 83 c1 00 28 lwz r30,40(r1)
ffc0c988: 7c 08 03 a6 mtlr r0
ffc0c98c: 83 e1 00 2c lwz r31,44(r1)
ffc0c990: 38 21 00 30 addi r1,r1,48
ffc0c994: 4e 80 00 20 blr
* This was response was questionable but the best we could
* come up with.
*/
if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){
if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )
ffc0c998: 81 3f 00 14 lwz r9,20(r31) <== NOT EXECUTED
ffc0c99c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc0c9a0: 80 09 00 20 lwz r0,32(r9) <== NOT EXECUTED
ffc0c9a4: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc0c9a8: 4e 80 04 21 bctrl <== NOT EXECUTED
ffc0c9ac: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
rtems_fatal_error_occurred( 0 );
return -1;
ffc0c9b0: 38 60 ff ff li r3,-1 <== NOT EXECUTED
* This was response was questionable but the best we could
* come up with.
*/
if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){
if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )
ffc0c9b4: 41 9e ff cc beq+ cr7,ffc0c980 <unmount+0x104> <== NOT EXECUTED
rtems_fatal_error_occurred( 0 );
ffc0c9b8: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc0c9bc: 48 00 18 b1 bl ffc0e26c <rtems_fatal_error_occurred> <== NOT EXECUTED
/*
* Verify this is the root node for the file system to be unmounted.
*/
if ( fs_root_loc->node_access != loc.node_access ){
rtems_filesystem_freenode( &loc );
ffc0c9c0: 4b ff ba f5 bl ffc084b4 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EACCES );
ffc0c9c4: 48 01 78 4d bl ffc24210 <__errno>
ffc0c9c8: 38 00 00 0d li r0,13
ffc0c9cc: 90 03 00 00 stw r0,0(r3)
ffc0c9d0: 38 60 ff ff li r3,-1
rtems_filesystem_freenode( fs_mount_loc );
free( mt_entry );
return 0;
}
ffc0c9d4: 80 01 00 34 lwz r0,52(r1)
ffc0c9d8: 83 c1 00 28 lwz r30,40(r1)
ffc0c9dc: 7c 08 03 a6 mtlr r0
ffc0c9e0: 83 e1 00 2c lwz r31,44(r1)
ffc0c9e4: 38 21 00 30 addi r1,r1,48
ffc0c9e8: 4e 80 00 20 blr
ffc0c9ec: 80 01 00 34 lwz r0,52(r1)
* 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 )
return -1;
ffc0c9f0: 38 60 ff ff li r3,-1
rtems_filesystem_freenode( fs_mount_loc );
free( mt_entry );
return 0;
}
ffc0c9f4: 83 c1 00 28 lwz r30,40(r1)
ffc0c9f8: 7c 08 03 a6 mtlr r0
ffc0c9fc: 83 e1 00 2c lwz r31,44(r1)
ffc0ca00: 38 21 00 30 addi r1,r1,48
ffc0ca04: 4e 80 00 20 blr
* descriptors that are currently active and reference nodes in the
* file system that we are trying to unmount
*/
if ( rtems_libio_is_open_files_in_fs( mt_entry ) == 1 )
rtems_set_errno_and_return_minus_one( EBUSY );
ffc0ca08: 48 01 78 09 bl ffc24210 <__errno>
ffc0ca0c: 38 00 00 10 li r0,16
ffc0ca10: 90 03 00 00 stw r0,0(r3)
ffc0ca14: 38 60 ff ff li r3,-1
ffc0ca18: 4b ff ff 68 b ffc0c980 <unmount+0x104>
ffc08738 <vprintk>:
*/
void vprintk(
const char *fmt,
va_list ap
)
{
ffc08738: 94 21 ff a8 stwu r1,-88(r1)
ffc0873c: 7d 80 00 26 mfcr r12
ffc08740: 7c 08 02 a6 mflr r0
ffc08744: 93 01 00 38 stw r24,56(r1)
ffc08748: 7c 98 23 78 mr r24,r4
ffc0874c: 93 e1 00 54 stw r31,84(r1)
ffc08750: 7c 7f 1b 78 mr r31,r3
ffc08754: 90 01 00 5c stw r0,92(r1)
ffc08758: 92 a1 00 2c stw r21,44(r1)
ffc0875c: 92 c1 00 30 stw r22,48(r1)
ffc08760: 92 e1 00 34 stw r23,52(r1)
ffc08764: 93 21 00 3c stw r25,60(r1)
ffc08768: 93 41 00 40 stw r26,64(r1)
ffc0876c: 93 61 00 44 stw r27,68(r1)
ffc08770: 93 81 00 48 stw r28,72(r1)
ffc08774: 93 a1 00 4c stw r29,76(r1)
ffc08778: 93 c1 00 50 stw r30,80(r1)
ffc0877c: 91 81 00 28 stw r12,40(r1)
for (; *fmt != '\0'; fmt++) {
ffc08780: 88 63 00 00 lbz r3,0(r3)
ffc08784: 2f 83 00 00 cmpwi cr7,r3,0
ffc08788: 41 9e 01 04 beq- cr7,ffc0888c <vprintk+0x154> <== NEVER TAKEN
bool sign = false;
char lead = ' ';
char c;
if (*fmt != '%') {
BSP_output_char(*fmt);
ffc0878c: 3e e0 00 00 lis r23,0
* console is not yet initialized or in ISR's.
*
* Arguments:
* as in printf: fmt - format string, ... - unnamed arguments.
*/
void vprintk(
ffc08790: 3b a1 00 08 addi r29,r1,8
ffc08794: 3e c0 ff c2 lis r22,-62
char *s, *str;
str = va_arg(ap, char *);
if ( str == NULL ) {
str = "";
ffc08798: 3e a0 ff c2 lis r21,-62
bool minus = false;
bool sign = false;
char lead = ' ';
char c;
if (*fmt != '%') {
ffc0879c: 2f 83 00 25 cmpwi cr7,r3,37
ffc087a0: 40 9e 00 d0 bne- cr7,ffc08870 <vprintk+0x138>
BSP_output_char(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
ffc087a4: 88 7f 00 01 lbz r3,1(r31)
ffc087a8: 2f 83 00 30 cmpwi cr7,r3,48
ffc087ac: 41 9e 02 24 beq- cr7,ffc089d0 <vprintk+0x298>
if (*fmt != '%') {
BSP_output_char(*fmt);
continue;
}
fmt++;
ffc087b0: 3b ff 00 01 addi r31,r31,1
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
bool sign = false;
char lead = ' ';
ffc087b4: 3b 40 00 20 li r26,32
fmt++;
if (*fmt == '0' ) {
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
ffc087b8: 2f 83 00 2d cmpwi cr7,r3,45
{
for (; *fmt != '\0'; fmt++) {
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
ffc087bc: 39 60 00 00 li r11,0
fmt++;
if (*fmt == '0' ) {
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
ffc087c0: 41 9e 02 00 beq- cr7,ffc089c0 <vprintk+0x288>
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
ffc087c4: 38 03 ff d0 addi r0,r3,-48
ffc087c8: 54 00 06 3e clrlwi r0,r0,24
ffc087cc: 2b 80 00 09 cmplwi cr7,r0,9
ffc087d0: 3b c0 00 00 li r30,0
ffc087d4: 41 9d 00 2c bgt- cr7,ffc08800 <vprintk+0xc8>
ffc087d8: 7f e9 fb 78 mr r9,r31
width *= 10;
ffc087dc: 1f de 00 0a mulli r30,r30,10
width += ((unsigned) *fmt - '0');
ffc087e0: 7f de 1a 14 add r30,r30,r3
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
ffc087e4: 8c 69 00 01 lbzu r3,1(r9)
width *= 10;
width += ((unsigned) *fmt - '0');
ffc087e8: 3b de ff d0 addi r30,r30,-48
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
ffc087ec: 38 03 ff d0 addi r0,r3,-48
ffc087f0: 54 00 06 3e clrlwi r0,r0,24
ffc087f4: 2b 80 00 09 cmplwi cr7,r0,9
width *= 10;
width += ((unsigned) *fmt - '0');
fmt++;
ffc087f8: 3b ff 00 01 addi r31,r31,1
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
ffc087fc: 40 9d ff e0 ble+ cr7,ffc087dc <vprintk+0xa4>
width *= 10;
width += ((unsigned) *fmt - '0');
fmt++;
}
if ((c = *fmt) == 'l') {
ffc08800: 2f 83 00 6c cmpwi cr7,r3,108
ffc08804: 41 9e 02 20 beq- cr7,ffc08a24 <vprintk+0x2ec>
lflag = true;
c = *++fmt;
}
if ( c == 'c' ) {
ffc08808: 2f 83 00 63 cmpwi cr7,r3,99
ffc0880c: 41 9e 01 d4 beq- cr7,ffc089e0 <vprintk+0x2a8>
/* need a cast here since va_arg() only takes fully promoted types */
char chr = (char) va_arg(ap, int);
BSP_output_char(chr);
continue;
}
if ( c == 's' ) {
ffc08810: 2f 83 00 73 cmpwi cr7,r3,115
ffc08814: 41 9e 02 38 beq- cr7,ffc08a4c <vprintk+0x314>
continue;
}
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
ffc08818: 2f 83 00 6f cmpwi cr7,r3,111
ffc0881c: 41 9e 02 24 beq- cr7,ffc08a40 <vprintk+0x308>
ffc08820: 2f 83 00 4f cmpwi cr7,r3,79
ffc08824: 41 9e 02 1c beq- cr7,ffc08a40 <vprintk+0x308>
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
ffc08828: 2f 83 00 69 cmpwi cr7,r3,105
ffc0882c: 41 9e 00 a4 beq- cr7,ffc088d0 <vprintk+0x198>
ffc08830: 2f 83 00 49 cmpwi cr7,r3,73
ffc08834: 41 9e 00 9c beq- cr7,ffc088d0 <vprintk+0x198>
ffc08838: 2f 83 00 64 cmpwi cr7,r3,100
ffc0883c: 41 9e 00 94 beq- cr7,ffc088d0 <vprintk+0x198>
c == 'd' || c == 'D' ) {
ffc08840: 2f 83 00 44 cmpwi cr7,r3,68
ffc08844: 41 9e 00 8c beq- cr7,ffc088d0 <vprintk+0x198>
base = 10; sign = true;
} else if ( c == 'u' || c == 'U' ) {
ffc08848: 2f 83 00 75 cmpwi cr7,r3,117
ffc0884c: 41 9e 03 40 beq- cr7,ffc08b8c <vprintk+0x454>
ffc08850: 2f 83 00 55 cmpwi cr7,r3,85
ffc08854: 41 9e 03 38 beq- cr7,ffc08b8c <vprintk+0x454>
base = 10; sign = false;
} else if ( c == 'x' || c == 'X' ) {
ffc08858: 2f 83 00 78 cmpwi cr7,r3,120
ffc0885c: 41 9e 03 3c beq- cr7,ffc08b98 <vprintk+0x460>
ffc08860: 2f 83 00 58 cmpwi cr7,r3,88
ffc08864: 41 9e 03 34 beq- cr7,ffc08b98 <vprintk+0x460>
base = 16; sign = false;
} else if ( c == 'p' ) {
ffc08868: 2f 83 00 70 cmpwi cr7,r3,112
ffc0886c: 41 9e 03 2c beq- cr7,ffc08b98 <vprintk+0x460>
base = 16; sign = false; lflag = true;
} else {
BSP_output_char(c);
ffc08870: 80 17 27 74 lwz r0,10100(r23)
ffc08874: 7c 09 03 a6 mtctr r0
ffc08878: 4e 80 04 21 bctrl
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
ffc0887c: 88 7f 00 01 lbz r3,1(r31)
ffc08880: 3b ff 00 01 addi r31,r31,1
ffc08884: 2f 83 00 00 cmpwi cr7,r3,0
ffc08888: 40 9e ff 14 bne+ cr7,ffc0879c <vprintk+0x64>
sign,
width,
lead
);
}
}
ffc0888c: 80 01 00 5c lwz r0,92(r1)
ffc08890: 81 81 00 28 lwz r12,40(r1)
ffc08894: 7c 08 03 a6 mtlr r0
ffc08898: 82 a1 00 2c lwz r21,44(r1)
ffc0889c: 82 c1 00 30 lwz r22,48(r1)
ffc088a0: 7d 80 81 20 mtcrf 8,r12
ffc088a4: 82 e1 00 34 lwz r23,52(r1)
ffc088a8: 83 01 00 38 lwz r24,56(r1)
ffc088ac: 83 21 00 3c lwz r25,60(r1)
ffc088b0: 83 41 00 40 lwz r26,64(r1)
ffc088b4: 83 61 00 44 lwz r27,68(r1)
ffc088b8: 83 81 00 48 lwz r28,72(r1)
ffc088bc: 83 a1 00 4c lwz r29,76(r1)
ffc088c0: 83 c1 00 50 lwz r30,80(r1)
ffc088c4: 83 e1 00 54 lwz r31,84(r1)
ffc088c8: 38 21 00 58 addi r1,r1,88
ffc088cc: 4e 80 00 20 blr
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
c == 'd' || c == 'D' ) {
base = 10; sign = true;
ffc088d0: 39 20 00 01 li r9,1
ffc088d4: 3b 80 00 0a li r28,10
BSP_output_char(c);
continue;
}
printNum(
lflag ? va_arg(ap, long) : (long) va_arg(ap, int),
ffc088d8: 89 78 00 00 lbz r11,0(r24)
ffc088dc: 2b 8b 00 08 cmplwi cr7,r11,8
ffc088e0: 40 9c 01 50 bge- cr7,ffc08a30 <vprintk+0x2f8>
ffc088e4: 55 60 10 3a rlwinm r0,r11,2,0,29
ffc088e8: 81 58 00 08 lwz r10,8(r24)
ffc088ec: 39 6b 00 01 addi r11,r11,1
ffc088f0: 99 78 00 00 stb r11,0(r24)
ffc088f4: 7d 4a 02 14 add r10,r10,r0
unsigned long unsigned_num;
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
ffc088f8: 2f 89 00 00 cmpwi cr7,r9,0
} else {
BSP_output_char(c);
continue;
}
printNum(
ffc088fc: 83 6a 00 00 lwz r27,0(r10)
unsigned long unsigned_num;
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
ffc08900: 41 9e 00 0c beq- cr7,ffc0890c <vprintk+0x1d4>
ffc08904: 2f 9b 00 00 cmpwi cr7,r27,0
ffc08908: 41 9c 02 9c blt- cr7,ffc08ba4 <vprintk+0x46c>
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
ffc0890c: 7c 1b e3 96 divwu r0,r27,r28
ffc08910: 2f 80 00 00 cmpwi cr7,r0,0
ffc08914: 57 88 06 3e clrlwi r8,r28,24
if (maxwidth) maxwidth--;
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
ffc08918: 39 20 00 00 li r9,0
while ((n = unsigned_num / base) > 0) {
ffc0891c: 40 be 00 10 bne+ cr7,ffc0892c <vprintk+0x1f4>
ffc08920: 48 00 02 a8 b ffc08bc8 <vprintk+0x490>
ffc08924: 7c 1b 03 78 mr r27,r0
ffc08928: 7d 60 5b 78 mr r0,r11
ffc0892c: 7d 60 e3 96 divwu r11,r0,r28
ffc08930: 2f 8b 00 00 cmpwi cr7,r11,0
toPrint[count++] = (char) (unsigned_num - (n * base));
ffc08934: 7d 48 01 d6 mullw r10,r8,r0
ffc08938: 7f 6a d8 50 subf r27,r10,r27
ffc0893c: 7f 7d 49 ae stbx r27,r29,r9
ffc08940: 39 29 00 01 addi r9,r9,1
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
ffc08944: 40 9e ff e0 bne+ cr7,ffc08924 <vprintk+0x1ec>
ffc08948: 3b 69 00 01 addi r27,r9,1
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
ffc0894c: 7f 9e d8 40 cmplw cr7,r30,r27
count = 0;
while ((n = unsigned_num / base) > 0) {
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
ffc08950: 7d 21 4a 14 add r9,r1,r9
ffc08954: 98 09 00 08 stb r0,8(r9)
for (n=maxwidth ; n > count; n-- )
ffc08958: 40 9d 00 24 ble- cr7,ffc0897c <vprintk+0x244>
ffc0895c: 3b 97 27 74 addi r28,r23,10100
BSP_output_char(lead);
ffc08960: 80 1c 00 00 lwz r0,0(r28)
ffc08964: 7f 43 d3 78 mr r3,r26
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
ffc08968: 3b de ff ff addi r30,r30,-1
BSP_output_char(lead);
ffc0896c: 7c 09 03 a6 mtctr r0
ffc08970: 4e 80 04 21 bctrl
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
ffc08974: 7f 9e d8 40 cmplw cr7,r30,r27
ffc08978: 41 9d ff e8 bgt+ cr7,ffc08960 <vprintk+0x228>
BSP_output_char(lead);
for (n = 0; n < count; n++) {
ffc0897c: 2f 9b 00 00 cmpwi cr7,r27,0
ffc08980: 41 be fe fc beq- cr7,ffc0887c <vprintk+0x144> <== NEVER TAKEN
* console is not yet initialized or in ISR's.
*
* Arguments:
* as in printf: fmt - format string, ... - unnamed arguments.
*/
void vprintk(
ffc08984: 7f dd da 14 add r30,r29,r27
ffc08988: 3b 97 27 74 addi r28,r23,10100
ffc0898c: 3b 76 0c 3c addi r27,r22,3132
for (n=maxwidth ; n > count; n-- )
BSP_output_char(lead);
for (n = 0; n < count; n++) {
BSP_output_char("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]);
ffc08990: 8d 3e ff ff lbzu r9,-1(r30)
ffc08994: 80 1c 00 00 lwz r0,0(r28)
ffc08998: 7c 7b 48 ae lbzx r3,r27,r9
ffc0899c: 7c 09 03 a6 mtctr r0
ffc089a0: 4e 80 04 21 bctrl
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
BSP_output_char(lead);
for (n = 0; n < count; n++) {
ffc089a4: 7f 9e e8 00 cmpw cr7,r30,r29
ffc089a8: 40 9e ff e8 bne+ cr7,ffc08990 <vprintk+0x258>
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
ffc089ac: 88 7f 00 01 lbz r3,1(r31)
ffc089b0: 3b ff 00 01 addi r31,r31,1
ffc089b4: 2f 83 00 00 cmpwi cr7,r3,0
ffc089b8: 40 9e fd e4 bne+ cr7,ffc0879c <vprintk+0x64> <== ALWAYS TAKEN
ffc089bc: 4b ff fe d0 b ffc0888c <vprintk+0x154> <== NOT EXECUTED
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
minus = true;
fmt++;
ffc089c0: 88 7f 00 01 lbz r3,1(r31)
if (*fmt == '0' ) {
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
minus = true;
ffc089c4: 39 60 00 01 li r11,1
fmt++;
ffc089c8: 3b ff 00 01 addi r31,r31,1
ffc089cc: 4b ff fd f8 b ffc087c4 <vprintk+0x8c>
continue;
}
fmt++;
if (*fmt == '0' ) {
lead = '0';
fmt++;
ffc089d0: 88 7f 00 02 lbz r3,2(r31)
BSP_output_char(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
lead = '0';
ffc089d4: 3b 40 00 30 li r26,48
fmt++;
ffc089d8: 3b ff 00 02 addi r31,r31,2
ffc089dc: 4b ff fd dc b ffc087b8 <vprintk+0x80>
lflag = true;
c = *++fmt;
}
if ( c == 'c' ) {
/* need a cast here since va_arg() only takes fully promoted types */
char chr = (char) va_arg(ap, int);
ffc089e0: 89 38 00 00 lbz r9,0(r24)
ffc089e4: 2b 89 00 08 cmplwi cr7,r9,8
ffc089e8: 40 9c 01 74 bge- cr7,ffc08b5c <vprintk+0x424> <== NEVER TAKEN
ffc089ec: 55 20 10 3a rlwinm r0,r9,2,0,29
ffc089f0: 81 78 00 08 lwz r11,8(r24)
ffc089f4: 39 29 00 01 addi r9,r9,1
ffc089f8: 99 38 00 00 stb r9,0(r24)
ffc089fc: 7d 6b 02 14 add r11,r11,r0
BSP_output_char(chr);
ffc08a00: 80 17 27 74 lwz r0,10100(r23)
ffc08a04: 88 6b 00 03 lbz r3,3(r11)
ffc08a08: 7c 09 03 a6 mtctr r0
ffc08a0c: 4e 80 04 21 bctrl
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
ffc08a10: 88 7f 00 01 lbz r3,1(r31)
ffc08a14: 3b ff 00 01 addi r31,r31,1
ffc08a18: 2f 83 00 00 cmpwi cr7,r3,0
ffc08a1c: 40 9e fd 80 bne+ cr7,ffc0879c <vprintk+0x64> <== ALWAYS TAKEN
ffc08a20: 4b ff fe 6c b ffc0888c <vprintk+0x154> <== NOT EXECUTED
fmt++;
}
if ((c = *fmt) == 'l') {
lflag = true;
c = *++fmt;
ffc08a24: 88 7f 00 01 lbz r3,1(r31)
ffc08a28: 3b ff 00 01 addi r31,r31,1
ffc08a2c: 4b ff fd dc b ffc08808 <vprintk+0xd0>
BSP_output_char(c);
continue;
}
printNum(
lflag ? va_arg(ap, long) : (long) va_arg(ap, int),
ffc08a30: 81 58 00 04 lwz r10,4(r24)
ffc08a34: 38 0a 00 04 addi r0,r10,4
ffc08a38: 90 18 00 04 stw r0,4(r24)
ffc08a3c: 4b ff fe bc b ffc088f8 <vprintk+0x1c0>
continue;
}
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
base = 8; sign = false;
ffc08a40: 39 20 00 00 li r9,0
ffc08a44: 3b 80 00 08 li r28,8
ffc08a48: 4b ff fe 90 b ffc088d8 <vprintk+0x1a0>
}
if ( c == 's' ) {
unsigned i, len;
char *s, *str;
str = va_arg(ap, char *);
ffc08a4c: 89 38 00 00 lbz r9,0(r24)
ffc08a50: 2b 89 00 08 cmplwi cr7,r9,8
ffc08a54: 40 9c 01 18 bge- cr7,ffc08b6c <vprintk+0x434> <== NEVER TAKEN
ffc08a58: 55 20 10 3a rlwinm r0,r9,2,0,29
ffc08a5c: 81 58 00 08 lwz r10,8(r24)
ffc08a60: 39 29 00 01 addi r9,r9,1
ffc08a64: 99 38 00 00 stb r9,0(r24)
ffc08a68: 7d 4a 02 14 add r10,r10,r0
ffc08a6c: 83 4a 00 00 lwz r26,0(r10)
if ( str == NULL ) {
ffc08a70: 2f 9a 00 00 cmpwi cr7,r26,0
ffc08a74: 41 9e 01 10 beq- cr7,ffc08b84 <vprintk+0x44c>
str = "";
}
/* calculate length of string */
for ( len=0, s=str ; *s ; len++, s++ )
ffc08a78: 88 1a 00 00 lbz r0,0(r26)
ffc08a7c: 3b 60 00 00 li r27,0
ffc08a80: 2f 80 00 00 cmpwi cr7,r0,0
ffc08a84: 41 9e 00 18 beq- cr7,ffc08a9c <vprintk+0x364>
ffc08a88: 7f 49 d3 78 mr r9,r26
ffc08a8c: 8c 09 00 01 lbzu r0,1(r9)
ffc08a90: 3b 7b 00 01 addi r27,r27,1
ffc08a94: 2f 80 00 00 cmpwi cr7,r0,0
ffc08a98: 40 9e ff f4 bne+ cr7,ffc08a8c <vprintk+0x354>
;
/* leading spaces */
if ( !minus )
ffc08a9c: 2e 0b 00 00 cmpwi cr4,r11,0
ffc08aa0: 40 92 00 30 bne- cr4,ffc08ad0 <vprintk+0x398>
for ( i=len ; i<width ; i++ )
ffc08aa4: 7f 9b f0 40 cmplw cr7,r27,r30
ffc08aa8: 40 9c 00 28 bge- cr7,ffc08ad0 <vprintk+0x398>
ffc08aac: 7f 79 db 78 mr r25,r27
ffc08ab0: 3b 97 27 74 addi r28,r23,10100
BSP_output_char(' ');
ffc08ab4: 80 1c 00 00 lwz r0,0(r28)
ffc08ab8: 38 60 00 20 li r3,32
for ( len=0, s=str ; *s ; len++, s++ )
;
/* leading spaces */
if ( !minus )
for ( i=len ; i<width ; i++ )
ffc08abc: 3b 39 00 01 addi r25,r25,1
BSP_output_char(' ');
ffc08ac0: 7c 09 03 a6 mtctr r0
ffc08ac4: 4e 80 04 21 bctrl
for ( len=0, s=str ; *s ; len++, s++ )
;
/* leading spaces */
if ( !minus )
for ( i=len ; i<width ; i++ )
ffc08ac8: 7f 99 f0 40 cmplw cr7,r25,r30
ffc08acc: 41 9c ff e8 blt+ cr7,ffc08ab4 <vprintk+0x37c>
BSP_output_char(' ');
/* no width option */
if (width == 0) {
ffc08ad0: 2f 9e 00 00 cmpwi cr7,r30,0
ffc08ad4: 40 9e 00 10 bne- cr7,ffc08ae4 <vprintk+0x3ac>
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
ffc08ad8: 2f 9b 00 00 cmpwi cr7,r27,0
ffc08adc: 41 9e 00 40 beq- cr7,ffc08b1c <vprintk+0x3e4>
ffc08ae0: 7f 7e db 78 mr r30,r27
ffc08ae4: 88 7a 00 00 lbz r3,0(r26)
ffc08ae8: 2f 83 00 00 cmpwi cr7,r3,0
ffc08aec: 41 9e 00 30 beq- cr7,ffc08b1c <vprintk+0x3e4> <== NEVER TAKEN
BSP_output_char(*str);
ffc08af0: 80 17 27 74 lwz r0,10100(r23)
ffc08af4: 3b 97 27 74 addi r28,r23,10100
ffc08af8: 7c 09 03 a6 mtctr r0
ffc08afc: 4e 80 04 21 bctrl
ffc08b00: 48 00 00 10 b ffc08b10 <vprintk+0x3d8>
ffc08b04: 80 1c 00 00 lwz r0,0(r28)
ffc08b08: 7c 09 03 a6 mtctr r0
ffc08b0c: 4e 80 04 21 bctrl
if (width == 0) {
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
ffc08b10: 8c 7a 00 01 lbzu r3,1(r26)
ffc08b14: 2f 83 00 00 cmpwi cr7,r3,0
ffc08b18: 40 9e ff ec bne+ cr7,ffc08b04 <vprintk+0x3cc>
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
ffc08b1c: 41 b2 fd 60 beq- cr4,ffc0887c <vprintk+0x144>
for ( i=len ; i<width ; i++ )
ffc08b20: 7f 9b f0 40 cmplw cr7,r27,r30
ffc08b24: 40 bc fd 58 bge- cr7,ffc0887c <vprintk+0x144>
ffc08b28: 3b 97 27 74 addi r28,r23,10100
BSP_output_char(' ');
ffc08b2c: 80 1c 00 00 lwz r0,0(r28)
ffc08b30: 38 60 00 20 li r3,32
for ( i=0 ; i<width && *str ; str++ )
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
for ( i=len ; i<width ; i++ )
ffc08b34: 3b 7b 00 01 addi r27,r27,1
BSP_output_char(' ');
ffc08b38: 7c 09 03 a6 mtctr r0
ffc08b3c: 4e 80 04 21 bctrl
for ( i=0 ; i<width && *str ; str++ )
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
for ( i=len ; i<width ; i++ )
ffc08b40: 7f 9b f0 40 cmplw cr7,r27,r30
ffc08b44: 41 9c ff e8 blt+ cr7,ffc08b2c <vprintk+0x3f4>
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
ffc08b48: 88 7f 00 01 lbz r3,1(r31)
ffc08b4c: 3b ff 00 01 addi r31,r31,1
ffc08b50: 2f 83 00 00 cmpwi cr7,r3,0
ffc08b54: 40 9e fc 48 bne+ cr7,ffc0879c <vprintk+0x64> <== ALWAYS TAKEN
ffc08b58: 4b ff fd 34 b ffc0888c <vprintk+0x154> <== NOT EXECUTED
lflag = true;
c = *++fmt;
}
if ( c == 'c' ) {
/* need a cast here since va_arg() only takes fully promoted types */
char chr = (char) va_arg(ap, int);
ffc08b5c: 81 78 00 04 lwz r11,4(r24) <== NOT EXECUTED
ffc08b60: 38 0b 00 04 addi r0,r11,4 <== NOT EXECUTED
ffc08b64: 90 18 00 04 stw r0,4(r24) <== NOT EXECUTED
ffc08b68: 4b ff fe 98 b ffc08a00 <vprintk+0x2c8> <== NOT EXECUTED
}
if ( c == 's' ) {
unsigned i, len;
char *s, *str;
str = va_arg(ap, char *);
ffc08b6c: 81 58 00 04 lwz r10,4(r24) <== NOT EXECUTED
ffc08b70: 38 0a 00 04 addi r0,r10,4 <== NOT EXECUTED
ffc08b74: 90 18 00 04 stw r0,4(r24) <== NOT EXECUTED
ffc08b78: 83 4a 00 00 lwz r26,0(r10) <== NOT EXECUTED
if ( str == NULL ) {
ffc08b7c: 2f 9a 00 00 cmpwi cr7,r26,0 <== NOT EXECUTED
ffc08b80: 40 9e fe f8 bne+ cr7,ffc08a78 <vprintk+0x340> <== NOT EXECUTED
str = "";
ffc08b84: 3b 55 fc b0 addi r26,r21,-848
ffc08b88: 4b ff fe f0 b ffc08a78 <vprintk+0x340>
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
c == 'd' || c == 'D' ) {
base = 10; sign = true;
} else if ( c == 'u' || c == 'U' ) {
base = 10; sign = false;
ffc08b8c: 39 20 00 00 li r9,0
ffc08b90: 3b 80 00 0a li r28,10
ffc08b94: 4b ff fd 44 b ffc088d8 <vprintk+0x1a0>
} else if ( c == 'x' || c == 'X' ) {
base = 16; sign = false;
} else if ( c == 'p' ) {
base = 16; sign = false; lflag = true;
ffc08b98: 39 20 00 00 li r9,0
ffc08b9c: 3b 80 00 10 li r28,16
ffc08ba0: 4b ff fd 38 b ffc088d8 <vprintk+0x1a0>
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
BSP_output_char('-');
ffc08ba4: 80 17 27 74 lwz r0,10100(r23)
ffc08ba8: 38 60 00 2d li r3,45
unsigned_num = (unsigned long) -num;
ffc08bac: 7f 7b 00 d0 neg r27,r27
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
BSP_output_char('-');
ffc08bb0: 7c 09 03 a6 mtctr r0
ffc08bb4: 4e 80 04 21 bctrl
unsigned_num = (unsigned long) -num;
if (maxwidth) maxwidth--;
ffc08bb8: 2f 9e 00 00 cmpwi cr7,r30,0
ffc08bbc: 41 be fd 50 beq- cr7,ffc0890c <vprintk+0x1d4>
ffc08bc0: 3b de ff ff addi r30,r30,-1
ffc08bc4: 4b ff fd 48 b ffc0890c <vprintk+0x1d4>
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
ffc08bc8: 7f 60 db 78 mr r0,r27
if (maxwidth) maxwidth--;
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
ffc08bcc: 39 20 00 00 li r9,0
while ((n = unsigned_num / base) > 0) {
ffc08bd0: 3b 60 00 01 li r27,1
ffc08bd4: 4b ff fd 78 b ffc0894c <vprintk+0x214>
ffc1ee90 <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
ffc1ee90: 94 21 ff f0 stwu r1,-16(r1)
ffc1ee94: 7c 08 02 a6 mflr r0
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
ffc1ee98: 3d 20 00 00 lis r9,0
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
ffc1ee9c: 90 01 00 14 stw r0,20(r1)
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
ffc1eea0: 80 09 27 3c lwz r0,10044(r9)
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
ffc1eea4: 93 e1 00 0c stw r31,12(r1)
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
ffc1eea8: 7f 83 00 40 cmplw cr7,r3,r0
ffc1eeac: 40 9c 00 8c bge- cr7,ffc1ef38 <write+0xa8>
iop = rtems_libio_iop( fd );
ffc1eeb0: 3d 60 00 00 lis r11,0
ffc1eeb4: 83 eb 27 f0 lwz r31,10224(r11)
ffc1eeb8: 54 63 30 32 rlwinm r3,r3,6,0,25
ffc1eebc: 7f ff 1a 14 add r31,r31,r3
rtems_libio_check_is_open( iop );
ffc1eec0: 81 7f 00 18 lwz r11,24(r31)
ffc1eec4: 71 6a 01 00 andi. r10,r11,256
ffc1eec8: 41 82 00 70 beq- ffc1ef38 <write+0xa8>
rtems_libio_check_buffer( buffer );
ffc1eecc: 2f 84 00 00 cmpwi cr7,r4,0
ffc1eed0: 41 9e 00 7c beq- cr7,ffc1ef4c <write+0xbc> <== NEVER TAKEN
rtems_libio_check_count( count );
ffc1eed4: 2f 85 00 00 cmpwi cr7,r5,0
ffc1eed8: 38 60 00 00 li r3,0
ffc1eedc: 41 9e 00 48 beq- cr7,ffc1ef24 <write+0x94>
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
ffc1eee0: 71 60 00 04 andi. r0,r11,4
ffc1eee4: 41 82 00 54 beq- ffc1ef38 <write+0xa8>
/*
* Now process the write() request.
*/
rc = (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
ffc1eee8: 81 3f 00 24 lwz r9,36(r31)
ffc1eeec: 7f e3 fb 78 mr r3,r31
ffc1eef0: 80 09 00 0c lwz r0,12(r9)
ffc1eef4: 7c 09 03 a6 mtctr r0
ffc1eef8: 4e 80 04 21 bctrl
if ( rc > 0 )
ffc1eefc: 2c 03 00 00 cmpwi r3,0
ffc1ef00: 40 81 00 24 ble- ffc1ef24 <write+0x94>
iop->offset += rc;
ffc1ef04: 81 1f 00 10 lwz r8,16(r31)
ffc1ef08: 7c 6b 1b 78 mr r11,r3
ffc1ef0c: 81 3f 00 14 lwz r9,20(r31)
ffc1ef10: 7c 6a fe 70 srawi r10,r3,31
ffc1ef14: 7d 6b 48 14 addc r11,r11,r9
ffc1ef18: 7d 4a 41 14 adde r10,r10,r8
ffc1ef1c: 91 5f 00 10 stw r10,16(r31)
ffc1ef20: 91 7f 00 14 stw r11,20(r31)
return rc;
}
ffc1ef24: 80 01 00 14 lwz r0,20(r1)
ffc1ef28: 83 e1 00 0c lwz r31,12(r1)
ffc1ef2c: 38 21 00 10 addi r1,r1,16
ffc1ef30: 7c 08 03 a6 mtlr r0
ffc1ef34: 4e 80 00 20 blr
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
ffc1ef38: 4b ff 4e 55 bl ffc13d8c <__errno>
ffc1ef3c: 38 00 00 09 li r0,9
ffc1ef40: 90 03 00 00 stw r0,0(r3)
ffc1ef44: 38 60 ff ff li r3,-1
ffc1ef48: 4b ff ff dc b ffc1ef24 <write+0x94>
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
ffc1ef4c: 4b ff 4e 41 bl ffc13d8c <__errno> <== NOT EXECUTED
ffc1ef50: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc1ef54: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1ef58: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc1ef5c: 4b ff ff c8 b ffc1ef24 <write+0x94> <== NOT EXECUTED
ffc09bd8 <writev>:
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
ffc09bd8: 94 21 ff d8 stwu r1,-40(r1)
ffc09bdc: 7c 08 02 a6 mflr r0
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
ffc09be0: 3d 20 00 00 lis r9,0
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
ffc09be4: 90 01 00 2c stw r0,44(r1)
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
ffc09be8: 80 09 27 1c lwz r0,10012(r9)
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
ffc09bec: 93 a1 00 1c stw r29,28(r1)
ffc09bf0: 7c 9d 23 78 mr r29,r4
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
ffc09bf4: 7f 83 00 40 cmplw cr7,r3,r0
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
ffc09bf8: 93 01 00 08 stw r24,8(r1)
ffc09bfc: 93 21 00 0c stw r25,12(r1)
ffc09c00: 93 41 00 10 stw r26,16(r1)
ffc09c04: 93 61 00 14 stw r27,20(r1)
ffc09c08: 93 81 00 18 stw r28,24(r1)
ffc09c0c: 93 c1 00 20 stw r30,32(r1)
ffc09c10: 93 e1 00 24 stw r31,36(r1)
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
ffc09c14: 40 9c 01 64 bge- cr7,ffc09d78 <writev+0x1a0>
iop = rtems_libio_iop( fd );
ffc09c18: 3d 20 00 00 lis r9,0
ffc09c1c: 83 29 27 cc lwz r25,10188(r9)
ffc09c20: 54 63 30 32 rlwinm r3,r3,6,0,25
ffc09c24: 7f 39 1a 14 add r25,r25,r3
rtems_libio_check_is_open( iop );
ffc09c28: 80 19 00 18 lwz r0,24(r25)
ffc09c2c: 70 09 01 00 andi. r9,r0,256
ffc09c30: 41 82 01 48 beq- ffc09d78 <writev+0x1a0>
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
ffc09c34: 70 09 00 04 andi. r9,r0,4
ffc09c38: 41 82 01 40 beq- ffc09d78 <writev+0x1a0> <== NEVER TAKEN
/*
* Argument validation on IO vector
*/
if ( !iov )
ffc09c3c: 2f 84 00 00 cmpwi cr7,r4,0
ffc09c40: 41 9e 00 f4 beq- cr7,ffc09d34 <writev+0x15c>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
ffc09c44: 2f 85 00 00 cmpwi cr7,r5,0
ffc09c48: 40 9d 00 ec ble- cr7,ffc09d34 <writev+0x15c>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
ffc09c4c: 2f 85 04 00 cmpwi cr7,r5,1024
ffc09c50: 41 9d 00 e4 bgt- cr7,ffc09d34 <writev+0x15c> <== NEVER TAKEN
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t writev(
ffc09c54: 54 ba 18 38 rlwinm r26,r5,3,0,28
ffc09c58: 39 7a ff f8 addi r11,r26,-8
ffc09c5c: 55 6b e8 fe rlwinm r11,r11,29,3,31
ffc09c60: 39 6b 00 01 addi r11,r11,1
ffc09c64: 7d 69 03 a6 mtctr r11
ffc09c68: 39 20 00 00 li r9,0
ffc09c6c: 39 00 00 01 li r8,1
ffc09c70: 38 00 00 00 li r0,0
/*
* 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 )
ffc09c74: 7d 7d 48 2e lwzx r11,r29,r9
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t writev(
ffc09c78: 7d 5d 4a 14 add r10,r29,r9
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
rtems_set_errno_and_return_minus_one( EINVAL );
ffc09c7c: 39 29 00 08 addi r9,r9,8
/*
* 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 )
ffc09c80: 2f 8b 00 00 cmpwi cr7,r11,0
ffc09c84: 41 9e 00 b0 beq- cr7,ffc09d34 <writev+0x15c>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
ffc09c88: 81 4a 00 04 lwz r10,4(r10)
all_zeros = false;
/* check for wrap */
old = total;
total += iov[v].iov_len;
ffc09c8c: 7d 6a 02 14 add r11,r10,r0
if ( total < old || total > SSIZE_MAX )
ffc09c90: 7f 80 58 00 cmpw cr7,r0,r11
*/
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
all_zeros = false;
ffc09c94: 31 4a ff ff addic r10,r10,-1
ffc09c98: 7d 4a 51 10 subfe r10,r10,r10
ffc09c9c: 7d 08 50 38 and r8,r8,r10
* 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++ ) {
ffc09ca0: 7d 60 5b 78 mr r0,r11
all_zeros = false;
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
ffc09ca4: 41 9d 00 90 bgt- cr7,ffc09d34 <writev+0x15c>
* 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++ ) {
ffc09ca8: 42 00 ff cc bdnz+ ffc09c74 <writev+0x9c>
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
ffc09cac: 2f 88 00 00 cmpwi cr7,r8,0
return 0;
ffc09cb0: 3b 00 00 00 li r24,0
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
ffc09cb4: 40 9e 00 90 bne- cr7,ffc09d44 <writev+0x16c>
ffc09cb8: 3b 80 00 00 li r28,0
ffc09cbc: 48 00 00 10 b ffc09ccc <writev+0xf4>
if ( bytes > 0 ) {
iop->offset += bytes;
total += bytes;
}
if (bytes != iov[ v ].iov_len)
ffc09cc0: 3b 9c 00 08 addi r28,r28,8
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
ffc09cc4: 7f 9c d0 00 cmpw cr7,r28,r26
ffc09cc8: 41 9e 00 7c beq- cr7,ffc09d44 <writev+0x16c>
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t writev(
ffc09ccc: 7f 7d e2 14 add r27,r29,r28
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
/* all zero lengths has no effect */
if ( iov[v].iov_len == 0 )
ffc09cd0: 80 bb 00 04 lwz r5,4(r27)
ffc09cd4: 2f 85 00 00 cmpwi cr7,r5,0
ffc09cd8: 41 9e ff e8 beq+ cr7,ffc09cc0 <writev+0xe8> <== NEVER TAKEN
continue;
bytes = (*iop->pathinfo.handlers->write_h)(
ffc09cdc: 81 39 00 24 lwz r9,36(r25)
ffc09ce0: 7f 23 cb 78 mr r3,r25
ffc09ce4: 7c 9d e0 2e lwzx r4,r29,r28
ffc09ce8: 80 09 00 0c lwz r0,12(r9)
ffc09cec: 7c 09 03 a6 mtctr r0
ffc09cf0: 4e 80 04 21 bctrl
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
ffc09cf4: 2c 03 00 00 cmpwi r3,0
ffc09cf8: 41 80 00 94 blt- ffc09d8c <writev+0x1b4> <== NEVER TAKEN
return -1;
if ( bytes > 0 ) {
ffc09cfc: 41 82 00 28 beq- ffc09d24 <writev+0x14c> <== NEVER TAKEN
iop->offset += bytes;
ffc09d00: 81 59 00 10 lwz r10,16(r25)
ffc09d04: 7c 7f 1b 78 mr r31,r3
ffc09d08: 81 79 00 14 lwz r11,20(r25)
ffc09d0c: 7c 7e fe 70 srawi r30,r3,31
total += bytes;
ffc09d10: 7f 18 1a 14 add r24,r24,r3
if ( bytes < 0 )
return -1;
if ( bytes > 0 ) {
iop->offset += bytes;
ffc09d14: 7d 6b f8 14 addc r11,r11,r31
ffc09d18: 7d 4a f1 14 adde r10,r10,r30
ffc09d1c: 91 59 00 10 stw r10,16(r25)
ffc09d20: 91 79 00 14 stw r11,20(r25)
total += bytes;
}
if (bytes != iov[ v ].iov_len)
ffc09d24: 80 1b 00 04 lwz r0,4(r27)
ffc09d28: 7f 83 00 00 cmpw cr7,r3,r0
ffc09d2c: 41 9e ff 94 beq+ cr7,ffc09cc0 <writev+0xe8> <== ALWAYS TAKEN
ffc09d30: 48 00 00 14 b ffc09d44 <writev+0x16c> <== NOT EXECUTED
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
rtems_set_errno_and_return_minus_one( EINVAL );
ffc09d34: 48 00 ab 59 bl ffc1488c <__errno>
ffc09d38: 38 00 00 16 li r0,22
ffc09d3c: 90 03 00 00 stw r0,0(r3)
ffc09d40: 3b 00 ff ff li r24,-1
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
ffc09d44: 80 01 00 2c lwz r0,44(r1)
ffc09d48: 7f 03 c3 78 mr r3,r24
ffc09d4c: 83 21 00 0c lwz r25,12(r1)
ffc09d50: 7c 08 03 a6 mtlr r0
ffc09d54: 83 01 00 08 lwz r24,8(r1)
ffc09d58: 83 41 00 10 lwz r26,16(r1)
ffc09d5c: 83 61 00 14 lwz r27,20(r1)
ffc09d60: 83 81 00 18 lwz r28,24(r1)
ffc09d64: 83 a1 00 1c lwz r29,28(r1)
ffc09d68: 83 c1 00 20 lwz r30,32(r1)
ffc09d6c: 83 e1 00 24 lwz r31,36(r1)
ffc09d70: 38 21 00 28 addi r1,r1,40
ffc09d74: 4e 80 00 20 blr
bool all_zeros;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
ffc09d78: 48 00 ab 15 bl ffc1488c <__errno>
ffc09d7c: 38 00 00 09 li r0,9
ffc09d80: 90 03 00 00 stw r0,0(r3)
ffc09d84: 3b 00 ff ff li r24,-1
ffc09d88: 4b ff ff bc b ffc09d44 <writev+0x16c>
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
ffc09d8c: 3b 00 ff ff li r24,-1 <== NOT EXECUTED
ffc09d90: 4b ff ff b4 b ffc09d44 <writev+0x16c> <== NOT EXECUTED